Return to dispnew.c CVS log

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

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

1.1     ! root        1: /* Newly written part of redisplay code.
        !             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 <signal.h>
        !            23: 
        !            24: #include "config.h"
        !            25: #include <stdio.h>
        !            26: 
        !            27: #ifdef HAVE_TIMEVAL
        !            28: #ifdef HPUX
        !            29: #include <time.h>
        !            30: #else
        !            31: #include <sys/time.h>
        !            32: #endif
        !            33: #endif
        !            34: 
        !            35: #ifdef USG
        !            36: #include <termio.h>
        !            37: #else /* not USG */
        !            38: #include <sys/ioctl.h>
        !            39: #endif /* not USG */
        !            40: 
        !            41: #undef NULL
        !            42: 
        !            43: #include "termchar.h"
        !            44: #include "termopts.h"
        !            45: #include "cm.h"
        !            46: #include "dispextern.h"
        !            47: #include "lisp.h"
        !            48: #include "buffer.h"
        !            49: #include "window.h"
        !            50: #include "commands.h"
        !            51: 
        !            52: #define max(a, b) ((a) > (b) ? (a) : (b))
        !            53: #define min(a, b) ((a) < (b) ? (a) : (b))
        !            54: 
        !            55: /* Nonzero means do not assume anything about current
        !            56:  contents of actual terminal screen */
        !            57: 
        !            58: int screen_garbaged;
        !            59: 
        !            60: /* Desired terminal cursor position (to show position of point),
        !            61:  origin zero */
        !            62: 
        !            63: int cursX, cursY;
        !            64: 
        !            65: /* Nonzero means last display completed and cursor is really at cursX, cursY.
        !            66:  Zero means it was preempted. */
        !            67: 
        !            68: int display_completed;
        !            69: 
        !            70: int visible_bell;      /* If true and the terminal will support it
        !            71:                           then the screen will flash instead of
        !            72:                           feeping when an error occurs */
        !            73: int inverse_video;     /* If true and the terminal will support it
        !            74:                           then we will use inverse video */
        !            75: 
        !            76: int baud_rate;         /* Terminal speed, so we can calculate
        !            77:                           the number of characters required to
        !            78:                           make the cursor sit still for n secs. */
        !            79: 
        !            80: /* the current (physical) screen */
        !            81: struct display_line *PhysScreen[MScreenLength + 1];
        !            82: 
        !            83: /* temporary Copy of PhysScreen made in update_screen */
        !            84: struct display_line *OPhysScreen[MScreenLength + 1];
        !            85: 
        !            86: /* the desired (virtual) screen */
        !            87: struct display_line *DesiredScreen[MScreenLength + 1];
        !            88: 
        !            89: /* Record here all the display line objects, for debugging.  */
        !            90: static struct display_line *all_lines[2 * MScreenLength];
        !            91: 
        !            92: FILE *termscript;      /* Stdio stream being used for copy of all kbdinput.  */
        !            93: 
        !            94: struct cm Wcm;         /* Structure for info on cursor positioning */
        !            95: 
        !            96: extern short ospeed;   /* Output speed (from sg_ospeed) */
        !            97: 
        !            98: /* Use these to chain together free lines */
        !            99: 
        !           100: #define LINE_NEXT(l) (*(struct display_line **) l)
        !           101: #define SET_LINE_NEXT(l, next) (*((struct display_line **) l) = next)
        !           102: 
        !           103: /* Chain of free display_line structures, chained thru LINE_NEXT.  */
        !           104: 
        !           105: struct display_line *free_display_lines;
        !           106: 
        !           107: /* Number of lines now free.  */
        !           108: 
        !           109: int free_line_count;
        !           110: 
        !           111: /* Allocate as many display_line structures
        !           112:    as we are ever supposed to need.
        !           113:    Called at startup, and also if screen size is changed.  */
        !           114: 
        !           115: make_display_lines ()
        !           116: {
        !           117:   register int i;
        !           118:   register struct display_line *p, *p1;
        !           119: 
        !           120:   /* First, free any that are already allocated */
        !           121: 
        !           122:   for (p = free_display_lines; p;)
        !           123:     {
        !           124:       p1 = p;
        !           125:       p = LINE_NEXT (p);
        !           126:       free (p1);
        !           127:     }
        !           128:   free_display_lines = 0;
        !           129:   free_line_count = 0;
        !           130: 
        !           131:   for (i = 0; i <= MScreenLength; i++)
        !           132:     if (PhysScreen[i])
        !           133:       {
        !           134:        free (PhysScreen[i]);
        !           135:        PhysScreen[i] = 0;
        !           136:       }
        !           137: 
        !           138:   screen_garbaged = 1;
        !           139: 
        !           140:   /* Now allocate as many as we can possibly validly need */
        !           141: 
        !           142:   for (i = - screen_height; i < screen_height; i++)
        !           143:     {
        !           144:       p = (struct display_line *) malloc (sizeof (struct display_line) + screen_width - MScreenWidth);
        !           145:       if (!p) abort ();
        !           146:       SET_LINE_NEXT (p, free_display_lines);
        !           147:       free_display_lines = p;
        !           148:       all_lines[i + screen_height] = p;
        !           149:     }
        !           150:   free_line_count = 2 * screen_height;
        !           151: }
        !           152: 
        !           153: /* Get one of the previously malloc'd display_line structures
        !           154:    from the free pool.  */
        !           155: 
        !           156: struct display_line *
        !           157: new_display_line ()
        !           158: {
        !           159:   register struct display_line *p = free_display_lines;
        !           160:   /* If we ever use up all the display lines that have been
        !           161:      allocated, it indicates a bug, since we are supposed
        !           162:      to need at most two for each line on the screen.  */
        !           163:   if (!p)
        !           164:     abort ();
        !           165:   free_display_lines = LINE_NEXT (p);
        !           166: 
        !           167:   bzero (p, p->body - (char *) p);
        !           168:   SET_LINE_NEXT (p, (struct display_line *)1); /* Mark as in use.  */
        !           169:   free_line_count--;
        !           170:   return p;
        !           171: }
        !           172: 
        !           173: /* Put a display_line back in the free pool.  */
        !           174: 
        !           175: return_display_line (p)
        !           176:      struct display_line *p;
        !           177: {
        !           178:   if (!p)
        !           179:     return;
        !           180:   if ((int) LINE_NEXT (p) != 1)
        !           181:     abort ();                  /* Already free.  */
        !           182:   SET_LINE_NEXT (p, free_display_lines);
        !           183:   free_display_lines = p;
        !           184:   free_line_count++;
        !           185: }
        !           186: 
        !           187: clear_screen_records ()
        !           188: {
        !           189:   register int i;
        !           190:   for (i = 1; i <= screen_height; i++)
        !           191:     if (PhysScreen[i])
        !           192:       return_display_line (PhysScreen[i]);
        !           193:   bzero (PhysScreen, (screen_height + 1) * sizeof PhysScreen[0]);
        !           194: }
        !           195: 
        !           196: /* Return the hash code of display_line p.  */
        !           197: line_hash_code (p)
        !           198:      register struct display_line *p;
        !           199: {
        !           200:   register char *body, *end;
        !           201:   register int h = 0;
        !           202:   if (!p)
        !           203:     return 0;
        !           204:   /* Give all lighlighted lines the same hash code
        !           205:      so as to encourage scrolling to leave them in place.  */
        !           206:   if (p->highlighted)
        !           207:     return -1;
        !           208: 
        !           209:   body = p->body;
        !           210:   end = body + p->length;
        !           211:   *end = 0;
        !           212:   if (!must_write_spaces)
        !           213:     {
        !           214:       while (*body++ == ' ');
        !           215:       body--;
        !           216:       if (body == end)
        !           217:        return 1;
        !           218:       while (end[-1] == ' ') end--;
        !           219:     }
        !           220:   while (body != end)
        !           221:     h = (h << 5) + h + *body++;
        !           222:   if (h)
        !           223:     return h;
        !           224:   return 1;
        !           225: }
        !           226: 
        !           227: /* Return number of characters in display_line p,
        !           228:    except don't count leading and trailing spaces
        !           229:    unless the terminal requires those to be explicitly output.  */
        !           230: 
        !           231: line_draw_cost (p)
        !           232:      struct display_line *p;
        !           233: {
        !           234:   register char *body;
        !           235:   register int i;
        !           236: 
        !           237:   if (!p)
        !           238:     return 0;
        !           239: 
        !           240:   if (must_write_spaces)
        !           241:     return p->length;
        !           242: 
        !           243:   body = p->body - 1;
        !           244:   for (i = p->length; i > 0 && body[i - 1] == ' '; i--);
        !           245: 
        !           246:   i -= count_blanks (p->body);
        !           247:   return max (i, 0);
        !           248: }
        !           249: 
        !           250: /* The functions on this page are the interface from xdisp.c to redisplay.
        !           251:  They take cursor position arguments in origin 0.
        !           252: 
        !           253:  The only other interface into redisplay is through setting
        !           254:  cursX and cursY (in xdisp.c) and setting screen_garbaged. */
        !           255: 
        !           256: /* cancel_line eliminates any request to display a line at position `vpos' */
        !           257: 
        !           258: cancel_line (vpos)
        !           259:      int vpos;
        !           260: {
        !           261:   return_display_line (DesiredScreen[vpos + 1]);
        !           262:   DesiredScreen[vpos + 1] = 0;
        !           263: }
        !           264: 
        !           265: /* Get a display_line for displaying on line `vpos'
        !           266:  and set it up for outputting starting at `hpos' within it.  */
        !           267: 
        !           268: struct display_line *
        !           269: get_display_line (vpos, hpos)
        !           270:      int vpos;
        !           271:      register int hpos;
        !           272: {
        !           273:   register struct display_line *line;
        !           274:   register char *p;
        !           275: 
        !           276:   if (vpos < 0) abort ();
        !           277: 
        !           278:   line = DesiredScreen[vpos + 1];
        !           279:   if (line && line->length > hpos)
        !           280:     abort ();
        !           281:   if (!line)
        !           282:     line = new_display_line ();
        !           283: 
        !           284:   if (hpos > line->length)
        !           285:     {
        !           286:       p = line->body + line->length;
        !           287:       hpos -= line->length;
        !           288:       line->length += hpos;
        !           289:       while (--hpos >= 0)
        !           290:        *p++ = ' ';
        !           291:     }
        !           292: 
        !           293:   DesiredScreen[vpos + 1] = line;
        !           294: 
        !           295:   return line;
        !           296: }
        !           297: 
        !           298: /* Scroll lines from vpos `from' up to but not including vpos `end'
        !           299:  down by `amount' lines (`amount' may be negative).
        !           300:  Returns nonzero if done, zero if terminal cannot scroll them. */
        !           301: 
        !           302: int
        !           303: scroll_screen_lines (from, end, amount)
        !           304:      int from, end, amount;
        !           305: {
        !           306:   register int i;
        !           307: 
        !           308:   if (!line_ins_del_ok)
        !           309:     return 0;
        !           310: 
        !           311:   if (amount == 0)
        !           312:     return 1;
        !           313:   if (amount > 0)
        !           314:     {
        !           315:       set_terminal_window (end + amount);
        !           316:       if (!scroll_region_ok)
        !           317:        ins_del_lines (end, -amount);
        !           318:       ins_del_lines (from, amount);
        !           319:       set_terminal_window (0);
        !           320: 
        !           321:       for (i = end + amount; i >= end + 1; i--)
        !           322:        return_display_line (PhysScreen[i]);
        !           323:       for (i = end; i >= from + 1; i--)
        !           324:        PhysScreen[i + amount] = PhysScreen[i];
        !           325:       for (i = from + amount; i >= from + 1; i--)
        !           326:        PhysScreen[i] = 0;
        !           327:     }
        !           328:   if (amount < 0)
        !           329:     {
        !           330:       set_terminal_window (end);
        !           331:       ins_del_lines (from + amount, amount);
        !           332:       if (!scroll_region_ok)
        !           333:        ins_del_lines (end + amount, -amount);
        !           334:       set_terminal_window (0);
        !           335: 
        !           336:       for (i = from + amount + 1; i <= from; i++)
        !           337:        return_display_line (PhysScreen[i]);
        !           338:       for (i = from + 1; i <= end ; i++)
        !           339:        PhysScreen[i + amount] = PhysScreen[i];
        !           340:       for (i = end + amount + 1; i <= end; i++)
        !           341:        PhysScreen[i] = 0;
        !           342:     }
        !           343:   return 1;
        !           344: }
        !           345: 
        !           346: /* After updating a window w that isn't the full screen wide,
        !           347:  copy all the columns that w does not occupy
        !           348:  into the DesiredScreen lines from the PhysScreen lines
        !           349:  so that update_screen will not change those columns.  */
        !           350: 
        !           351: preserve_other_columns (w)
        !           352:      struct window *w;
        !           353: {
        !           354:   register int vpos;
        !           355:   register struct display_line *l1, *l2;
        !           356:   int start = XFASTINT (w->left);
        !           357:   int end = XFASTINT (w->left) + XFASTINT (w->width);
        !           358:   int bot = XFASTINT (w->top) + XFASTINT (w->height);
        !           359: 
        !           360:   for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
        !           361:     {
        !           362:       if ((l1 = DesiredScreen[vpos + 1])
        !           363:          && (l2 = PhysScreen[vpos + 1]))
        !           364:        {
        !           365:          if (start > 0)
        !           366:            {
        !           367:              bcopy (l2->body, l1->body, start);
        !           368:              if (l1->length < start && l1->length < l2->length)
        !           369:                l1->length = min (start, l2->length);
        !           370:            }
        !           371:          if (l2->length > end && l1->length < l2->length)
        !           372:            {
        !           373:              while (l1->length < end)
        !           374:                l1->body[l1->length++] = ' ';
        !           375:              bcopy (l2->body + end, l1->body + end, l2->length - end);
        !           376:              l1->length = l2->length;
        !           377:            }
        !           378:        }
        !           379:     }
        !           380: }
        !           381: 
        !           382: #ifdef NOTDEF
        !           383: 
        !           384: /* If window w does not need to be updated and isn't the full screen wide,
        !           385:  copy all the columns that w does occupy
        !           386:  into the DesiredScreen lines from the PhysScreen lines
        !           387:  so that update_screen will not change those columns.
        !           388: 
        !           389:  Have not been able to figure out how to use this correctly.  */
        !           390: 
        !           391: preserve_my_columns (w)
        !           392:      struct window *w;
        !           393: {
        !           394:   register int vpos, fin;
        !           395:   register struct display_line *l1, *l2;
        !           396:   int start = XFASTINT (w->left);
        !           397:   int end = XFASTINT (w->left) + XFASTINT (w->width);
        !           398:   int bot = XFASTINT (w->top) + XFASTINT (w->height);
        !           399: 
        !           400:   for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
        !           401:     {
        !           402:       if ((l1 = DesiredScreen[vpos + 1])
        !           403:          && (l2 = PhysScreen[vpos + 1]))
        !           404:        {
        !           405:          if (l2->length > start && l1->length < l2->length)
        !           406:            {
        !           407:              fin = l2->length;
        !           408:              if (fin > end) fin = end;
        !           409:              while (l1->length < start)
        !           410:                l1->body[l1->length++] = ' ';
        !           411:              bcopy (l2->body + start, l1->body + start, fin - start);
        !           412:              l1->length = fin;
        !           413:            }
        !           414:        }
        !           415:     }
        !           416: }
        !           417: 
        !           418: #endif /* NOTDEF */
        !           419: 
        !           420: /* On discovering that the redisplay for a window was no good,
        !           421:  cancel the columns of that window,
        !           422:  so that when the window is displayed over again
        !           423:  get_display_line will not complain. */
        !           424: 
        !           425: cancel_my_columns (w)
        !           426:      struct window *w;
        !           427: {
        !           428:   register int vpos;
        !           429:   register struct display_line *l;
        !           430:   register int start = XFASTINT (w->left);
        !           431:   register int bot = XFASTINT (w->top) + XFASTINT (w->height);
        !           432: 
        !           433:   for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
        !           434:     {
        !           435:       if ((l = DesiredScreen[vpos + 1])
        !           436:          && l->length >= start)
        !           437:        l->length = start;
        !           438:     }
        !           439: }
        !           440: 
        !           441: direct_output_for_insert (c)
        !           442:      int c;
        !           443: {
        !           444:   register struct display_line *p = PhysScreen[cursY + 1];
        !           445: #ifndef COMPILER_REGISTER_BUG
        !           446:   register
        !           447: #endif COMPILER_REGISTER_BUG
        !           448:     struct window *w = XWINDOW (selected_window);
        !           449: #ifndef COMPILER_REGISTER_BUG
        !           450:   register
        !           451: #endif COMPILER_REGISTER_BUG
        !           452:     int hpos = cursX;
        !           453: 
        !           454:   /* Give up if about to continue line */
        !           455:   if (hpos - XFASTINT (w->left) + 1 + 1 >= XFASTINT (w->width))
        !           456:     return;
        !           457: 
        !           458:   /* Avoid losing if cursor is in invisible text off left margin */
        !           459:   if (XINT (w->hscroll) && hpos == XFASTINT (w->left))
        !           460:     return;
        !           461:     
        !           462:   /* Give up if cursor outside window (in minibuf, probably) */
        !           463:   if (cursY < XFASTINT (w->top)
        !           464:       || cursY >= XFASTINT (w->top) + XFASTINT (w->height))
        !           465:     return;
        !           466: 
        !           467:   /* Give up if cursor not really at cursX, cursY */
        !           468:   if (!display_completed)
        !           469:     return;
        !           470: 
        !           471:   /* Give up if w is minibuffer and a message is being displayed there */
        !           472:   if (EQ (selected_window, minibuf_window) && minibuf_message)
        !           473:     return;
        !           474: 
        !           475:   p->body[hpos] = c;
        !           476:   unchanged_modified = bf_modified;
        !           477:   beg_unchanged = bf_s1;
        !           478:   XFASTINT (w->last_point) = point;
        !           479:   XFASTINT (w->last_point_x) = cursX;
        !           480:   XFASTINT (w->last_modified) = bf_modified;
        !           481: 
        !           482:   reassert_line_highlight (0, cursY);
        !           483:   write_chars (p->body + hpos, 1);
        !           484:   fflush (stdout);
        !           485:   ++cursX;
        !           486:   p->length = max (p->length, cursX);
        !           487:   p->body[p->length] = 0;
        !           488: }
        !           489: 
        !           490: direct_output_forward_char (n)
        !           491:      int n;
        !           492: {
        !           493:   register struct window *w = XWINDOW (selected_window);
        !           494: 
        !           495:   /* Avoid losing if cursor is in invisible text off left margin */
        !           496:   if (XINT (w->hscroll) && cursX == XFASTINT (w->left))
        !           497:     return;
        !           498: 
        !           499:   cursX += n;
        !           500:   XFASTINT (w->last_point_x) = cursX;
        !           501:   XFASTINT (w->last_point) = point;
        !           502:   topos (cursY, cursX);
        !           503:   fflush (stdout);
        !           504: }
        !           505: 
        !           506: /* At the time this function is called,
        !           507:  no line is common to PhysScreen and DesiredScreen.
        !           508:  That is true again when this function returns. */
        !           509: 
        !           510: /* `force' nonzero means do not stop for pending input */
        !           511: 
        !           512: /* Value is nonzero if redisplay stopped due to pending input */
        !           513: update_screen (force, inhibit_hairy_id)
        !           514:      int force;
        !           515:      int inhibit_hairy_id;
        !           516: {
        !           517:     register struct display_line **p;
        !           518:     register struct display_line *l, *lnew;
        !           519:     register int i;
        !           520:     int pause;
        !           521:     int preempt_count;
        !           522:     int outq;
        !           523:     extern input_pending;
        !           524: 
        !           525:     if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           526: 
        !           527:     bcopy (PhysScreen, OPhysScreen, sizeof PhysScreen);
        !           528: 
        !           529:     detect_input_pending ();
        !           530:     if (input_pending && !force)
        !           531:       {
        !           532:        pause = 1;
        !           533:        goto do_pause;
        !           534:       }
        !           535: 
        !           536:     update_begin ();
        !           537: 
        !           538:     if (!line_ins_del_ok)
        !           539:       inhibit_hairy_id = 1;
        !           540: 
        !           541:     /* Don't compute for i/d line if just want cursor motion. */
        !           542:     for (p = &DesiredScreen[screen_height]; p != DesiredScreen && *p == 0; p--);
        !           543: 
        !           544:     /* Try doing i/d line, if not yet inhibited.  */
        !           545:     if (!inhibit_hairy_id && p != DesiredScreen)
        !           546:       force |= scrolling ();
        !           547: 
        !           548:     /* Update the individual lines as needed.  Do bottom line first.  */
        !           549: 
        !           550:     l = DesiredScreen[screen_height];
        !           551:     if (l && l != PhysScreen[screen_height])
        !           552:       update_line (PhysScreen[screen_height], l, screen_height - 1);
        !           553:     preempt_count = baud_rate / 2400;
        !           554:     for (i = 1; i < screen_height && (force || !input_pending); i++)
        !           555:       {
        !           556:        l = PhysScreen[i];
        !           557:        lnew = DesiredScreen[i];
        !           558:        if (lnew && lnew != l)
        !           559:          {
        !           560:            /* Flush out every so many lines.
        !           561:               Also flush out if likely to have more than 1k buffered otherwise.
        !           562:               I'm told that telnet connections get really screwed by more
        !           563:               than 1k output at once.  */
        !           564:            outq = stdout->_ptr - stdout->_base;
        !           565:            if (outq > ((--preempt_count < 0) ? 20 : 900))
        !           566:              {
        !           567:                fflush (stdout);
        !           568:                if (baud_rate < 2400)
        !           569:                  {
        !           570: #ifdef TIOCOUTQ
        !           571:                    if (ioctl (0, TIOCOUTQ, &outq) < 0)
        !           572:                      /* Probably not a tty.  Ignore the error and reset
        !           573:                       * the outq count. */
        !           574:                      outq = stdout->_ptr - stdout->_base;
        !           575: #endif
        !           576:                    outq *= 10;
        !           577:                    outq /= baud_rate;  /* outq is now in seconds */
        !           578:                    if (outq)
        !           579:                      sleep (outq);
        !           580:                  }
        !           581:                detect_input_pending ();
        !           582: 
        !           583:                preempt_count = baud_rate / 2400;
        !           584:              }
        !           585:            /* Now update this line.  */
        !           586:            update_line (l, lnew, i - 1);
        !           587:          }
        !           588:       }
        !           589:     pause = (i < screen_height) ? i : 0;
        !           590: 
        !           591:     /* Now just clean up termcap drivers and set cursor, etc.  */
        !           592:     if (!pause)
        !           593:       topos (cursY, max (min (cursX, screen_width - 1), 0));
        !           594: 
        !           595:     update_end ();
        !           596: 
        !           597:     if (termscript)
        !           598:       fflush (termscript);
        !           599:     fflush (stdout);
        !           600: 
        !           601:   do_pause:
        !           602:     if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           603:     display_completed = !pause;
        !           604:     /* Free any lines still in desired screen but not in phys screen */
        !           605:     /* Free any lines that used to be in phys screen but are no longer */
        !           606:     for (p = &PhysScreen[screen_height]; p != PhysScreen; p--)
        !           607:       if (p[0]) p[0]->physical = 1;
        !           608:     for (p = &DesiredScreen[screen_height]; p != DesiredScreen; p--)
        !           609:       {
        !           610:        if (l = *p)
        !           611:          {
        !           612:            if (!l->physical)
        !           613:              {
        !           614:                return_display_line (l);
        !           615:                /* Prevent line in both DesiredScreen and OPhysScreen
        !           616:                   from being freed twice.  */
        !           617:                l->physical = 1;
        !           618:              }
        !           619:          }
        !           620:       }
        !           621:     for (p = &OPhysScreen[screen_height]; p != OPhysScreen; p--)
        !           622:       {
        !           623:        if (l = *p)
        !           624:          {
        !           625:            if (!l->physical)
        !           626:              return_display_line (l);
        !           627:          }
        !           628:       }
        !           629:     i = 0;
        !           630:     for (p = &PhysScreen[screen_height]; p != PhysScreen; p--)
        !           631:       if (p[0])
        !           632:        {
        !           633:          i++;
        !           634:          p[0]->physical = 0;
        !           635:        }
        !           636: 
        !           637:     {
        !           638:       extern int debug_end_pos;
        !           639:       if (debug_end_pos && i + free_line_count != 2 * screen_height)
        !           640:        abort ();
        !           641:     }
        !           642: 
        !           643:     bzero (OPhysScreen, (screen_height + 1) * sizeof OPhysScreen[0]);
        !           644:     bzero (DesiredScreen, (screen_height + 1) * sizeof DesiredScreen[0]);
        !           645:     return pause;
        !           646: }
        !           647: 
        !           648: /* Decide what insert/delete line to do, and do it */
        !           649: 
        !           650: scrolling ()
        !           651: {
        !           652:   int unchanged_at_top, unchanged_at_bottom;
        !           653:   int window_size;
        !           654:   int changed_lines;
        !           655:   int *old_hash = (int *) alloca (screen_height * sizeof (int));
        !           656:   int *new_hash = (int *) alloca (screen_height * sizeof (int));
        !           657:   int *draw_cost = (int *) alloca (screen_height * sizeof (int));
        !           658:   register int i;
        !           659:   int free_at_end_vpos = screen_height;
        !           660:   
        !           661:   /* Compute hash codes of all the lines.
        !           662:      Also calculate number of changed lines,
        !           663:      number of unchanged lines at the beginning,
        !           664:      and number of unchanged lines at the end.  */
        !           665: 
        !           666:   changed_lines = 0;
        !           667:   unchanged_at_top = 0;
        !           668:   unchanged_at_bottom = screen_height;
        !           669:   for (i = 0; i < screen_height; i++)
        !           670:     {
        !           671:       old_hash[i] = line_hash_code (PhysScreen[i + 1]);
        !           672:       if (!DesiredScreen[i + 1])
        !           673:        DesiredScreen[i + 1] = PhysScreen[i + 1];
        !           674:       if (PhysScreen[i + 1] == DesiredScreen[i + 1])
        !           675:        new_hash[i] = old_hash[i];
        !           676:       else
        !           677:        new_hash[i] = line_hash_code (DesiredScreen[i + 1]);
        !           678:       if (old_hash[i] != new_hash[i])
        !           679:        {
        !           680:          changed_lines++;
        !           681:          unchanged_at_bottom = screen_height - i - 1;
        !           682:        }
        !           683:       else if (i == unchanged_at_top)
        !           684:        unchanged_at_top++;
        !           685:       draw_cost[i] = line_draw_cost (DesiredScreen[i + 1]);
        !           686:     }
        !           687: 
        !           688:   /* If changed lines are few, don't allow preemption, don't scroll.  */
        !           689:   if (changed_lines < baud_rate / 2400 || unchanged_at_bottom == screen_height)
        !           690:     return 1;
        !           691: 
        !           692:   window_size = screen_height - unchanged_at_top - unchanged_at_bottom;
        !           693: 
        !           694:   if (scroll_region_ok)
        !           695:     free_at_end_vpos -= unchanged_at_bottom;
        !           696:   else if (memory_below_screen)
        !           697:     free_at_end_vpos = -1;
        !           698: 
        !           699:   /* If large window, fast terminal and few lines in common between
        !           700:      PhysScreen and DesiredScreen, don't bother with i/d calc.  */
        !           701:   if (window_size >= 18 && baud_rate > 2400
        !           702:       && (window_size >=
        !           703:          10 * scrolling_max_lines_saved (unchanged_at_top,
        !           704:                                          screen_height - unchanged_at_bottom,
        !           705:                                          old_hash, new_hash, draw_cost)))
        !           706:     return 0;
        !           707: 
        !           708:   scrolling_1 (window_size, unchanged_at_top, unchanged_at_bottom,
        !           709:               draw_cost + unchanged_at_top - 1,
        !           710:               old_hash + unchanged_at_top - 1,
        !           711:               new_hash + unchanged_at_top - 1,
        !           712:               free_at_end_vpos - unchanged_at_top);
        !           713: 
        !           714:   return 0;
        !           715: }
        !           716: 
        !           717: update_line (old, new, vpos)
        !           718:      struct display_line *old, *new;
        !           719:      int vpos;
        !           720: {
        !           721:   register char *obody, *nbody, *op1, *op2, *np1;
        !           722:   int tem;
        !           723:   int osp, nsp, m1, m2, olen, nlen;
        !           724:   int save;
        !           725: 
        !           726:   if (old == new)
        !           727:     return;
        !           728: 
        !           729:   /* Mark physical screen as containing the line `new' */
        !           730:   PhysScreen[vpos + 1] = new;
        !           731: 
        !           732:   if ((new && new->highlighted) != (old && old->highlighted))
        !           733:     {
        !           734:       change_line_highlight (new && new->highlighted, vpos, old ? old->length : 0);
        !           735:       old = 0;
        !           736:     }
        !           737:   else
        !           738:     reassert_line_highlight (new && new->highlighted, vpos);
        !           739: 
        !           740:   if (!old)
        !           741:     {
        !           742:       olen = 0;
        !           743:     }
        !           744:   else
        !           745:     {
        !           746:       obody = old -> body;
        !           747:       olen = old->length;
        !           748:       if (!must_write_spaces)
        !           749:        while (obody[olen - 1] == ' ')
        !           750:          olen--;
        !           751:     }
        !           752: 
        !           753:   if (!new)
        !           754:     {
        !           755:       nlen = 0;
        !           756:       goto just_erase;
        !           757:     }
        !           758: 
        !           759:   nbody = new -> body;
        !           760:   nlen = new->length;
        !           761: 
        !           762:   /* We know that the previous character is the `physical' field
        !           763:      and it is zero or one.  */
        !           764:   if (!must_write_spaces)
        !           765:     while (nbody[nlen - 1] == ' ')
        !           766:       nlen--;
        !           767: 
        !           768:   if (!olen)
        !           769:     {
        !           770:       nsp = (must_write_spaces || new->highlighted)
        !           771:              ? 0 : count_blanks (nbody);
        !           772:       if (nlen > nsp)
        !           773:        {
        !           774:          topos (vpos, nsp);
        !           775:          write_chars (nbody + nsp, nlen - nsp);
        !           776:        }
        !           777:       return;
        !           778:     }
        !           779: 
        !           780:   obody[olen] = 1;
        !           781:   save = nbody[nlen];
        !           782:   nbody[nlen] = 0;
        !           783: 
        !           784:   /* Compute number of leading blanks in old and new contents.  */
        !           785:   osp = count_blanks (obody);
        !           786:   if (!new->highlighted)
        !           787:     nsp = count_blanks (nbody);
        !           788:   else
        !           789:     nsp = 0;
        !           790: 
        !           791:   /* Compute number of matching chars starting with first nonblank.  */
        !           792:   m1 = count_match (obody + osp, nbody + nsp);
        !           793: 
        !           794:   /* Spaces in new match implicit space past the end of old.  */
        !           795:   /* This isn't really doing anything; osp should be osp + m1.
        !           796:      I don't dare fix it now since maybe if it does anything
        !           797:      it will do something bad.  */
        !           798:   if (!must_write_spaces && osp == olen)
        !           799:     {
        !           800:       np1 = nbody + nsp;
        !           801:       while (np1[m1] == ' ')
        !           802:        m1++;
        !           803:     }
        !           804: 
        !           805:   /* Avoid doing insert/delete char
        !           806:      just cause number of leading spaces differs
        !           807:      when the following text does not match. */
        !           808:   if (m1 == 0 && osp != nsp)
        !           809:     osp = nsp = min (osp, nsp);
        !           810: 
        !           811:   /* Find matching characters at end of line */
        !           812:   op1 = obody + olen;
        !           813:   np1 = nbody + nlen;
        !           814:   op2 = op1 + m1 - min (olen - osp, nlen - nsp);
        !           815:   while (op1 > op2 && op1[-1] == np1[-1])
        !           816:     {
        !           817:       op1--;
        !           818:       np1--;
        !           819:     }
        !           820:   m2 = obody + olen - op1;
        !           821: 
        !           822:   /* Put correct value back in nbody[nlen].
        !           823:      This is important because direct_output_for_insert
        !           824:      can write into the line at a later point.  */
        !           825:   nbody[nlen] = save;
        !           826: 
        !           827:   /* tem gets the distance to insert or delete.
        !           828:      m2 is how many characters we save by doing so.
        !           829:      Is it worth it?  */
        !           830: 
        !           831:   tem = (nlen - nsp) - (olen - osp);
        !           832:   if (m2 && tem && m2 <= DCICcost[tem])
        !           833:     m2 = 0;
        !           834: 
        !           835:   /* nsp - osp is the distance to insert or delete.
        !           836:      m1 + m2 is how much we save by doing so.
        !           837:      Is it worth it?  */
        !           838: 
        !           839:   if (m1 + m2 && nsp != osp && m1 + m2 <= DCICcost[nsp - osp])
        !           840:     {
        !           841:       m1 = 0;
        !           842:       m2 = 0;
        !           843:       osp = nsp = min (osp, nsp);
        !           844:     }
        !           845: 
        !           846:   /* Now go through the line, inserting, writing and deleting as appropriate.  */
        !           847: 
        !           848:   if (osp > nsp)
        !           849:     {
        !           850:       topos (vpos, nsp);
        !           851:       delete_chars (osp - nsp);
        !           852:     }
        !           853:   else if (nsp > osp)
        !           854:     {
        !           855:       /* If going to delete chars later in line
        !           856:         and insert earlier in the line,
        !           857:         must delete first to avoid losing data in the insert */
        !           858:       if (m2 && nlen < olen + nsp - osp)
        !           859:        {
        !           860:          topos (vpos, nlen - m2 + osp - nsp);
        !           861:          delete_chars (olen + nsp - osp - nlen);
        !           862:          olen = nlen - (nsp - osp);
        !           863:        }
        !           864:       topos (vpos, osp);
        !           865:       insert_chars ((char *)0, nsp - osp);
        !           866:     }
        !           867:   olen += nsp - osp;
        !           868:   osp = nsp;
        !           869: 
        !           870:   tem = nsp + m1 + m2;
        !           871:   if (nlen != tem || olen != tem)
        !           872:     {
        !           873:       topos (vpos, nsp + m1);
        !           874:       if (!m2 || nlen == olen)
        !           875:        {
        !           876:          /* If new text being written reaches right margin,
        !           877:             there is no need to do clear-to-eol at the end.
        !           878:             (and it would not be safe, since cursor is not
        !           879:             going to be "at the margin" after the text is done) */
        !           880:          if (nlen == screen_width)
        !           881:            olen = 0;
        !           882:          write_chars (nbody + nsp + m1, nlen - tem);
        !           883: #ifdef obsolete
        !           884: /* the following code loses disastrously if tem == nlen.
        !           885:    Rather than trying to fix that case, I am trying the simpler
        !           886:    solution found above.  */
        !           887:          /* If the text reaches to the right margin,
        !           888:             it will lose one way or another (depending on AutoWrap)
        !           889:             to clear to end of line after outputting all the text.
        !           890:             So pause with one character to go and clear the line then.  */
        !           891:          if (nlen == screen_width && fast_clear_end_of_line && olen > nlen)
        !           892:            {
        !           893:              /* m2 must be zero, and tem must equal nsp + m1 */
        !           894:              write_chars (nbody + tem, nlen - tem - 1);
        !           895:              clear_end_of_line (olen);
        !           896:              olen = 0;         /* Don't let it be cleared again later */
        !           897:              write_chars (nbody + nlen - 1, 1);
        !           898:            }
        !           899:          else
        !           900:            write_chars (nbody + nsp + m1, nlen - tem);
        !           901: #endif
        !           902:        }
        !           903:       else if (nlen > olen)
        !           904:        {
        !           905:          write_chars (nbody + nsp + m1, olen - tem);
        !           906:          insert_chars (nbody + nsp + m1 + olen - tem, nlen - olen);
        !           907:          olen = nlen;
        !           908:        }
        !           909:       else if (olen > nlen)
        !           910:        {
        !           911:          write_chars (nbody + nsp + m1, nlen - tem);
        !           912:          delete_chars (olen - nlen);
        !           913:          olen = nlen;
        !           914:        }
        !           915:     }
        !           916: 
        !           917:  just_erase:
        !           918:   /* If any unerased characters remain after the new line, erase them.  */
        !           919:   if (olen > nlen)
        !           920:     {
        !           921:       topos (vpos, nlen);
        !           922:       clear_end_of_line (olen);
        !           923:     }
        !           924: }
        !           925: 
        !           926: count_blanks (str)
        !           927:      char *str;
        !           928: {
        !           929:   register char *p = str;
        !           930:   while (*str++ == ' ');
        !           931:   return str - p - 1;
        !           932: }
        !           933: 
        !           934: count_match (str1, str2)
        !           935:      char *str1, *str2;
        !           936: {
        !           937:   register char *p1 = str1;
        !           938:   register char *p2 = str2;
        !           939:   while (*p1++ == *p2++);
        !           940:   return p1 - str1 - 1;
        !           941: }
        !           942: 
        !           943: DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
        !           944:   1, 1, "FOpen termscript file: ",
        !           945:   "Start writing all terminal output to FILE as well.")
        !           946:   (file)
        !           947:      Lisp_Object file;
        !           948: {
        !           949:   file = Fexpand_file_name (file, Qnil);
        !           950:   termscript = fopen (XSTRING (file)->data, "w");
        !           951:   return Qnil;
        !           952: }
        !           953: 
        !           954: DEFUN ("set-screen-height", Fset_screen_height, Sset_screen_height, 1, 1, 0,
        !           955:   "Set number of lines on screen available for use in windows.")
        !           956:   (n)
        !           957:      Lisp_Object n;
        !           958: {
        !           959:   CHECK_NUMBER (n, 0);
        !           960:   change_screen_size (XINT (n), 0);
        !           961:   return Qnil;
        !           962: }
        !           963: 
        !           964: DEFUN ("set-screen-width", Fset_screen_width, Sset_screen_width, 1, 1, 0,
        !           965:   "Set number of columns on screen available for display.")
        !           966:   (n)
        !           967:      Lisp_Object n;
        !           968: {
        !           969:   CHECK_NUMBER (n, 0);
        !           970:   change_screen_size (0, XINT (n));
        !           971:   return Qnil;
        !           972: }
        !           973: 
        !           974: DEFUN ("screen-height", Fscreen_height, Sscreen_height, 0, 0, 0,
        !           975:   "Return number of lines on screen available for use in windows.")
        !           976:   ()
        !           977: {
        !           978:   return make_number (screen_height);
        !           979: }
        !           980: 
        !           981: DEFUN ("screen-width", Fscreen_width, Sscreen_width, 0, 0, 0,
        !           982:   "Return number of columns on screen available for display.")
        !           983:   ()
        !           984: {
        !           985:   return make_number (screen_width);
        !           986: }
        !           987: 
        !           988: /* Change the screen height and/or width.  Values may be given as zero to
        !           989:    indicate no change is to take place. */
        !           990: change_screen_size (newlength, newwidth)
        !           991:      register int newlength, newwidth;
        !           992: {
        !           993:   if ((newlength == 0 || newlength == screen_height)
        !           994:          && (newwidth == 0 || newwidth == screen_width))
        !           995:       return;
        !           996:   if (newlength && newlength != screen_height)
        !           997:     {
        !           998:       if (newlength > MScreenLength)
        !           999:        newlength = MScreenLength;
        !          1000:       set_window_height (XWINDOW (minibuf_window)->prev, newlength - 1, 0);
        !          1001:       XFASTINT (XWINDOW (minibuf_window)->top) = newlength - 1;
        !          1002:       set_window_height (minibuf_window, 1, 0);
        !          1003:       screen_height = newlength;
        !          1004:       set_terminal_window (0);
        !          1005:     }
        !          1006:   if (newwidth && newwidth != screen_width)
        !          1007:     {
        !          1008:       if (newwidth > MScreenWidth)
        !          1009:        newwidth = MScreenWidth;
        !          1010:       set_window_width (XWINDOW (minibuf_window)->prev, newwidth, 0);
        !          1011:       set_window_width (minibuf_window, newwidth, 0);
        !          1012:       screen_width = newwidth;
        !          1013:     }
        !          1014:   make_display_lines ();
        !          1015:   calculate_costs ();
        !          1016:   DoDsp (1);
        !          1017: }
        !          1018: 
        !          1019: DEFSIMPLE ("baud-rate", Fbaud_rate, Sbaud_rate,
        !          1020:           "Return the output baud rate of the terminal.",
        !          1021:           Lisp_Int, XSETINT, baud_rate)
        !          1022: 
        !          1023: DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
        !          1024:   Ssend_string_to_terminal, 1, 1, 0,
        !          1025:   "Send STRING to the terminal without alteration.\n\
        !          1026: Control characters in STRING will have terminal-dependent effects.")
        !          1027:   (str)
        !          1028:      Lisp_Object str;
        !          1029: {
        !          1030:   CHECK_STRING (str, 0);
        !          1031:   fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, stdout);
        !          1032:   fflush (stdout);
        !          1033:   if (termscript)
        !          1034:     {
        !          1035:       fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, termscript);
        !          1036:       fflush (termscript);
        !          1037:     }
        !          1038:   return Qnil;
        !          1039: }
        !          1040: 
        !          1041: DEFUN ("ding", Fding, Sding, 0, 0, 0,
        !          1042:   "Beep, or flash the screen.\n\
        !          1043: Terminates any keyboard macro currently executing.")
        !          1044:   ()
        !          1045: {
        !          1046:   Ding ();
        !          1047:   return Qnil;
        !          1048: }
        !          1049: 
        !          1050: Ding ()
        !          1051: {
        !          1052:   if (noninteractive)
        !          1053:     putchar (07);
        !          1054:   else if (!INTERACTIVE)  /* Stop executing a keyboard macro. */
        !          1055:     error ("Keyboard macro terminated by a command ringing the bell");
        !          1056:   else
        !          1057:     ring_bell ();
        !          1058:   fflush (stdout);
        !          1059: }
        !          1060: 
        !          1061: DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 1, 0,
        !          1062:   "Pause, without updating display, for ARG seconds.")
        !          1063:   (n)
        !          1064:      Lisp_Object n;
        !          1065: {
        !          1066:   register int t;
        !          1067: #ifndef subprocesses
        !          1068: #ifdef HAVE_TIMEVAL
        !          1069:   struct timeval timeout, end_time, garbage1;
        !          1070: #endif /* HAVE_TIMEVAL */
        !          1071: #endif /* no subprocesses */
        !          1072: 
        !          1073:   CHECK_NUMBER (n, 0);
        !          1074:   t = XINT (n);
        !          1075:   if (t <= 0)
        !          1076:     return Qnil;
        !          1077: 
        !          1078: #ifdef subprocesses
        !          1079:   wait_reading_process_input (t, 0, 0);
        !          1080: #else /* No subprocesses */
        !          1081:   immediate_quit = 1;
        !          1082:   QUIT;
        !          1083: 
        !          1084: #if defined(HAVE_SELECT) && defined(HAVE_TIMEVAL)
        !          1085:   gettimeofday (&end_time, &garbage1);
        !          1086:   end_time.tv_sec += t;
        !          1087: 
        !          1088:   while (1)
        !          1089:     {
        !          1090:       gettimeofday (&timeout, &garbage1);
        !          1091:       timeout.tv_sec = end_time.tv_sec - timeout.tv_sec;
        !          1092:       timeout.tv_usec = end_time.tv_usec - timeout.tv_usec;
        !          1093:       if (timeout.tv_usec < 0)
        !          1094:        timeout.tv_usec += 1000000,
        !          1095:       timeout.tv_sec--;
        !          1096:       if (timeout.tv_sec < 0)
        !          1097:        break;
        !          1098:       if (!select (1, 0, 0, 0, &timeout))
        !          1099:        break;
        !          1100:     }
        !          1101: #else /* not both HAVE_SELECT and HAVE_TIMEVAL */
        !          1102:   /* Is it safe to quit out of `sleep'?  I'm afraid to trust it.  */
        !          1103:   sleep (t);
        !          1104: #endif /* not both HAVE_SELECT and HAVE_TIMEVAL */
        !          1105: 
        !          1106:   immediate_quit = 0;
        !          1107: #endif /* no subprocesses */
        !          1108:   return Qnil;
        !          1109: }
        !          1110: 
        !          1111: DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 1, 0,
        !          1112:   "Perform redisplay, then wait for ARG seconds or until input is available")
        !          1113:   (n)
        !          1114:      Lisp_Object n;
        !          1115: {
        !          1116: #ifndef subprocesses
        !          1117: #ifdef HAVE_TIMEVAL
        !          1118:   struct timeval timeout;
        !          1119: #else
        !          1120:   int timeout_sec;
        !          1121: #endif
        !          1122:   int waitchannels;
        !          1123: #endif /* no subprocesses */
        !          1124: 
        !          1125:   CHECK_NUMBER (n, 0);
        !          1126: 
        !          1127:   if (detect_input_pending ())
        !          1128:     return Qnil;
        !          1129: 
        !          1130:   DoDsp (1);                   /* Make the screen correct */
        !          1131:   if (XINT (n) <= 0) return Qnil;
        !          1132: 
        !          1133: #ifdef subprocesses
        !          1134: #ifdef SIGIO
        !          1135:   gobble_input ();
        !          1136: #endif /* SIGIO */
        !          1137:   wait_reading_process_input (XINT (n), 1, 1);
        !          1138: #else /* no subprocesses */
        !          1139:   immediate_quit = 1;
        !          1140:   QUIT;
        !          1141: 
        !          1142:   waitchannels = 1;
        !          1143: #ifndef HAVE_TIMEVAL
        !          1144:   timeout_sec = XINT (n);
        !          1145:   select (1, &waitchannels, 0, 0, &timeout_sec);
        !          1146: #else /* HAVE_TIMEVAL */
        !          1147:   timeout.tv_sec = XINT (n);  
        !          1148:   timeout.tv_usec = 0;
        !          1149:   select (1, &waitchannels, 0, 0, &timeout);
        !          1150: #endif /* HAVE_TIMEVAL */
        !          1151: 
        !          1152:   immediate_quit = 0;
        !          1153: #endif /* no subprocesses */
        !          1154:   return Qnil;
        !          1155: }
        !          1156: 
        !          1157: char *terminal_type;
        !          1158: 
        !          1159: /* Initialization done when Emacs fork is started, before doing stty. */
        !          1160: /* Determine terminal type and set terminal_driver */
        !          1161: /* Then invoke its decoding routine to set up variables
        !          1162:   in the terminal package */
        !          1163: 
        !          1164: init_display ()
        !          1165: {
        !          1166:   MetaFlag = 0;
        !          1167:   inverse_video = 0;
        !          1168: 
        !          1169:   /* Look at the TERM variable and set terminal_driver.  */
        !          1170: 
        !          1171:   terminal_type = (char *) getenv ("TERM");
        !          1172:   if (!terminal_type)
        !          1173:     {
        !          1174:       fprintf (stderr, "Please set the environment variable TERM; see tset(1).\n");
        !          1175:       exit (1);
        !          1176:     }
        !          1177: #ifdef HAVE_X_WINDOWS
        !          1178:   if (!strncmp (terminal_type, "xterm", 5))
        !          1179:     x_term_init ();
        !          1180:   else
        !          1181: #endif /* HAVE_X_WINDOWS */
        !          1182:     term_init (terminal_type);
        !          1183: 
        !          1184:   make_display_lines ();
        !          1185: 
        !          1186:   cursX = 0;           /* X and Y coordinates of the cursor */
        !          1187:   cursY = 0;           /* between updates. */
        !          1188: }
        !          1189: 
        !          1190: syms_of_display ()
        !          1191: {
        !          1192:   defsubr (&Sopen_termscript);
        !          1193:   defsubr (&Sding);
        !          1194:   defsubr (&Ssit_for);
        !          1195:   defsubr (&Sscreen_height);
        !          1196:   defsubr (&Sscreen_width);
        !          1197:   defsubr (&Sset_screen_height);
        !          1198:   defsubr (&Sset_screen_width);
        !          1199:   defsubr (&Ssleep_for);
        !          1200:   defsubr (&Sbaud_rate);
        !          1201:   defsubr (&Ssend_string_to_terminal);
        !          1202: 
        !          1203:   DefBoolVar ("inverse-video", &inverse_video,
        !          1204:     "*Non-nil means use inverse-video.");
        !          1205:   DefBoolVar ("visible-bell", &visible_bell,
        !          1206:     "*Non-nil means try to flash the screen to represent a bell.");
        !          1207: }

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