![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dispnew.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to dispnew.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Newly written part of redisplay code.
2: Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
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 HAVE_TERMIO
36: #include <termio.h>
37: #ifdef TCOUTQ
38: #undef TIOCOUTQ
39: #define TIOCOUTQ TCOUTQ
40: #endif /* TCOUTQ defined */
41: #else
42: #ifndef VMS
43: #include <sys/ioctl.h>
44: #endif /* not VMS */
45: #endif /* not HAVE_TERMIO */
46:
47: /* Allow m- file to inhibit use of FIONREAD. */
48: #ifdef BROKEN_FIONREAD
49: #undef FIONREAD
50: #undef SIGIO
51: #endif
52:
53: #undef NULL
54:
55: #include "termchar.h"
56: #include "termopts.h"
57: #include "cm.h"
58: #include "dispextern.h"
59: #include "lisp.h"
60: #include "buffer.h"
61: #include "window.h"
62: #include "commands.h"
63:
64: #define max(a, b) ((a) > (b) ? (a) : (b))
65: #define min(a, b) ((a) < (b) ? (a) : (b))
66:
67: #ifndef PENDING_OUTPUT_COUNT
68: /* Get number of chars of output now in the buffer of a stdio stream.
69: This ought to be built in in stdio, but it isn't.
70: Some s- files override this because their stdio internals differ. */
71: #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
72: #endif
73:
74: /* Nonzero means do not assume anything about current
75: contents of actual terminal screen */
76:
77: int screen_garbaged;
78:
79: /* Desired terminal cursor position (to show position of point),
80: origin zero */
81:
82: int cursX, cursY;
83:
84: /* Nonzero means last display completed and cursor is really at cursX, cursY.
85: Zero means it was preempted. */
86:
87: int display_completed;
88:
89: int visible_bell; /* If true and the terminal will support it
90: then the screen will flash instead of
91: feeping when an error occurs */
92: int inverse_video; /* If true and the terminal will support it
93: then we will use inverse video */
94:
95: int baud_rate; /* Terminal speed, so we can calculate
96: the number of characters required to
97: make the cursor sit still for n secs. */
98:
99: Lisp_Object Vwindow_system; /* nil or a symbol naming the window system
100: under which emacs is running
101: ('x is the only current possibility) */
102:
103: /* Version number of window system, or nil if no window system. */
104: Lisp_Object Vwindow_system_version;
105:
106: /* Nonzero means reading single-character input with prompt
107: so put cursor on minibuffer after the prompt. */
108:
109: int cursor_in_echo_area;
110:
111: /* the current (physical) screen */
112: struct display_line *PhysScreen[MScreenLength + 1];
113:
114: /* temporary Copy of PhysScreen made in update_screen */
115: struct display_line *OPhysScreen[MScreenLength + 1];
116:
117: /* the desired (virtual) screen */
118: struct display_line *DesiredScreen[MScreenLength + 1];
119:
120: /* Record here all the display line objects, for debugging. */
121: static struct display_line *all_lines[2 * MScreenLength];
122:
123: FILE *termscript; /* Stdio stream being used for copy of all kbdinput. */
124:
125: struct cm Wcm; /* Structure for info on cursor positioning */
126:
127: extern short ospeed; /* Output speed (from sg_ospeed) */
128:
129: int in_display; /* 1 if in redisplay: can't handle SIGWINCH now. */
130:
131: int delayed_size_change; /* 1 means SIGWINCH happened when not safe. */
132: int delayed_screen_height; /* Remembered new screen height. */
133: int delayed_screen_width; /* Remembered new screen width. */
134:
135: /* Use these to chain together free lines */
136:
137: #define LINE_NEXT(l) (*(struct display_line **) l)
138: #define SET_LINE_NEXT(l, next) (*((struct display_line **) l) = next)
139:
140: /* Chain of free display_line structures, chained thru LINE_NEXT. */
141:
142: struct display_line *free_display_lines;
143:
144: /* Number of lines now free. */
145:
146: int free_line_count;
147:
148: /* Allocate as many display_line structures
149: as we are ever supposed to need.
150: Called at startup, and also if screen size is changed. */
151:
152: make_display_lines ()
153: {
154: register int i;
155: register struct display_line *p, *p1;
156:
157: /* First, free any that are already allocated */
158:
159: for (p = free_display_lines; p;)
160: {
161: p1 = p;
162: p = LINE_NEXT (p);
163: free (p1);
164: }
165: free_display_lines = 0;
166: free_line_count = 0;
167:
168: for (i = 0; i <= MScreenLength; i++)
169: if (PhysScreen[i])
170: {
171: free (PhysScreen[i]);
172: PhysScreen[i] = 0;
173: }
174:
175: screen_garbaged = 1;
176:
177: /* Now allocate as many as we can possibly validly need */
178:
179: for (i = - screen_height; i < screen_height; i++)
180: {
181: p = (struct display_line *) malloc (sizeof (struct display_line) + screen_width - MScreenWidth);
182: if (!p) abort ();
183: SET_LINE_NEXT (p, free_display_lines);
184: free_display_lines = p;
185: all_lines[i + screen_height] = p;
186: }
187: free_line_count = 2 * screen_height;
188: }
189:
190: /* Get one of the previously malloc'd display_line structures
191: from the free pool. */
192:
193: struct display_line *
194: new_display_line ()
195: {
196: register struct display_line *p = free_display_lines;
197: /* If we ever use up all the display lines that have been
198: allocated, it indicates a bug, since we are supposed
199: to need at most two for each line on the screen. */
200: if (!p)
201: abort ();
202: free_display_lines = LINE_NEXT (p);
203:
204: bzero (p, p->body - (char *) p);
205: SET_LINE_NEXT (p, (struct display_line *)1); /* Mark as in use. */
206: free_line_count--;
207: return p;
208: }
209:
210: /* Put a display_line back in the free pool. */
211:
212: return_display_line (p)
213: struct display_line *p;
214: {
215: if (!p)
216: return;
217: if ((int) LINE_NEXT (p) != 1)
218: abort (); /* Already free. */
219: SET_LINE_NEXT (p, free_display_lines);
220: free_display_lines = p;
221: free_line_count++;
222: }
223:
224: clear_screen_records ()
225: {
226: register int i;
227: for (i = 1; i <= screen_height; i++)
228: if (PhysScreen[i])
229: return_display_line (PhysScreen[i]);
230: bzero (PhysScreen, (screen_height + 1) * sizeof PhysScreen[0]);
231: }
232:
233: /* Return the hash code of display_line p. */
234: line_hash_code (p)
235: register struct display_line *p;
236: {
237: register char *body, *end;
238: register int h = 0;
239: if (!p)
240: return 0;
241: /* Give all lighlighted lines the same hash code
242: so as to encourage scrolling to leave them in place. */
243: if (p->highlighted)
244: return -1;
245:
246: body = p->body;
247: end = body + p->length;
248: *end = 0;
249: if (!must_write_spaces)
250: {
251: while (*body++ == ' ');
252: body--;
253: if (body == end)
254: return 1;
255: while (end[-1] == ' ') end--;
256: }
257: while (body != end)
258: h = (h << 5) + h + *body++;
259: if (h)
260: return h;
261: return 1;
262: }
263:
264: /* Return number of characters in display_line p,
265: except don't count leading and trailing spaces
266: unless the terminal requires those to be explicitly output. */
267:
268: line_draw_cost (p)
269: struct display_line *p;
270: {
271: register char *body;
272: register int i;
273:
274: if (!p)
275: return 0;
276:
277: if (must_write_spaces)
278: return p->length;
279:
280: body = p->body - 1;
281: for (i = p->length; i > 0 && body[i - 1] == ' '; i--);
282:
283: i -= count_blanks (p->body);
284: return max (i, 0);
285: }
286:
287: /* The functions on this page are the interface from xdisp.c to redisplay.
288: They take cursor position arguments in origin 0.
289:
290: The only other interface into redisplay is through setting
291: cursX and cursY (in xdisp.c) and setting screen_garbaged. */
292:
293: /* cancel_line eliminates any request to display a line at position `vpos' */
294:
295: cancel_line (vpos)
296: int vpos;
297: {
298: return_display_line (DesiredScreen[vpos + 1]);
299: DesiredScreen[vpos + 1] = 0;
300: }
301:
302: /* Get a display_line for displaying on line `vpos'
303: and set it up for outputting starting at `hpos' within it. */
304:
305: struct display_line *
306: get_display_line (vpos, hpos)
307: int vpos;
308: register int hpos;
309: {
310: register struct display_line *line;
311: register char *p;
312:
313: if (vpos < 0) abort ();
314:
315: line = DesiredScreen[vpos + 1];
316: if (line && line->length > hpos)
317: abort ();
318: if (!line)
319: line = new_display_line ();
320:
321: if (hpos > line->length)
322: {
323: p = line->body + line->length;
324: hpos -= line->length;
325: line->length += hpos;
326: while (--hpos >= 0)
327: *p++ = ' ';
328: }
329:
330: DesiredScreen[vpos + 1] = line;
331:
332: return line;
333: }
334:
335: /* Scroll lines from vpos `from' up to but not including vpos `end'
336: down by `amount' lines (`amount' may be negative).
337: Returns nonzero if done, zero if terminal cannot scroll them. */
338:
339: int
340: scroll_screen_lines (from, end, amount)
341: int from, end, amount;
342: {
343: register int i;
344:
345: if (!line_ins_del_ok)
346: return 0;
347:
348: if (amount == 0)
349: return 1;
350: if (amount > 0)
351: {
352: set_terminal_window (end + amount);
353: if (!scroll_region_ok)
354: ins_del_lines (end, -amount);
355: ins_del_lines (from, amount);
356: set_terminal_window (0);
357:
358: for (i = end + amount; i >= end + 1; i--)
359: return_display_line (PhysScreen[i]);
360: for (i = end; i >= from + 1; i--)
361: PhysScreen[i + amount] = PhysScreen[i];
362: for (i = from + amount; i >= from + 1; i--)
363: PhysScreen[i] = 0;
364: }
365: if (amount < 0)
366: {
367: set_terminal_window (end);
368: ins_del_lines (from + amount, amount);
369: if (!scroll_region_ok)
370: ins_del_lines (end + amount, -amount);
371: set_terminal_window (0);
372:
373: for (i = from + amount + 1; i <= from; i++)
374: return_display_line (PhysScreen[i]);
375: for (i = from + 1; i <= end ; i++)
376: PhysScreen[i + amount] = PhysScreen[i];
377: for (i = end + amount + 1; i <= end; i++)
378: PhysScreen[i] = 0;
379: }
380: return 1;
381: }
382:
383: /* After updating a window w that isn't the full screen wide,
384: copy all the columns that w does not occupy
385: into the DesiredScreen lines from the PhysScreen lines
386: so that update_screen will not change those columns. */
387:
388: preserve_other_columns (w)
389: struct window *w;
390: {
391: register int vpos;
392: register struct display_line *l1, *l2;
393: int start = XFASTINT (w->left);
394: int end = XFASTINT (w->left) + XFASTINT (w->width);
395: int bot = XFASTINT (w->top) + XFASTINT (w->height);
396:
397: for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
398: {
399: if ((l1 = DesiredScreen[vpos + 1])
400: && (l2 = PhysScreen[vpos + 1]))
401: {
402: if (start > 0)
403: {
404: bcopy (l2->body, l1->body, start);
405: if (l1->length < start && l1->length < l2->length)
406: l1->length = min (start, l2->length);
407: }
408: if (l2->length > end && l1->length < l2->length)
409: {
410: while (l1->length < end)
411: l1->body[l1->length++] = ' ';
412: bcopy (l2->body + end, l1->body + end, l2->length - end);
413: l1->length = l2->length;
414: }
415: }
416: }
417: }
418:
419: #ifdef NOTDEF
420:
421: /* If window w does not need to be updated and isn't the full screen wide,
422: copy all the columns that w does occupy
423: into the DesiredScreen lines from the PhysScreen lines
424: so that update_screen will not change those columns.
425:
426: Have not been able to figure out how to use this correctly. */
427:
428: preserve_my_columns (w)
429: struct window *w;
430: {
431: register int vpos, fin;
432: register struct display_line *l1, *l2;
433: int start = XFASTINT (w->left);
434: int end = XFASTINT (w->left) + XFASTINT (w->width);
435: int bot = XFASTINT (w->top) + XFASTINT (w->height);
436:
437: for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
438: {
439: if ((l1 = DesiredScreen[vpos + 1])
440: && (l2 = PhysScreen[vpos + 1]))
441: {
442: if (l2->length > start && l1->length < l2->length)
443: {
444: fin = l2->length;
445: if (fin > end) fin = end;
446: while (l1->length < start)
447: l1->body[l1->length++] = ' ';
448: bcopy (l2->body + start, l1->body + start, fin - start);
449: l1->length = fin;
450: }
451: }
452: }
453: }
454:
455: #endif /* NOTDEF */
456:
457: /* On discovering that the redisplay for a window was no good,
458: cancel the columns of that window,
459: so that when the window is displayed over again
460: get_display_line will not complain. */
461:
462: cancel_my_columns (w)
463: struct window *w;
464: {
465: register int vpos;
466: register struct display_line *l;
467: register int start = XFASTINT (w->left);
468: register int bot = XFASTINT (w->top) + XFASTINT (w->height);
469:
470: for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
471: {
472: if ((l = DesiredScreen[vpos + 1])
473: && l->length >= start)
474: l->length = start;
475: }
476: }
477:
478: /* These functions try to perform directly and immediately on the screen
479: the necessary output for one change in the buffer.
480: They may return 0 meaning nothing was done if anything is difficult,
481: or 1 meaning the output was performed properly.
482: They assume that the screen was up to date before the buffer
483: change being displayed. THey make various other assumptions too;
484: see command_loop_1 where these are called. */
485:
486: int
487: direct_output_for_insert (c)
488: int c;
489: {
490: register struct display_line *p = PhysScreen[cursY + 1];
491: #ifndef COMPILER_REGISTER_BUG
492: register
493: #endif COMPILER_REGISTER_BUG
494: struct window *w = XWINDOW (selected_window);
495: #ifndef COMPILER_REGISTER_BUG
496: register
497: #endif COMPILER_REGISTER_BUG
498: int hpos = cursX;
499:
500: /* Give up if about to continue line */
501: if (hpos - XFASTINT (w->left) + 1 + 1 >= XFASTINT (w->width)
502:
503: /* Avoid losing if cursor is in invisible text off left margin */
504: || XINT (w->hscroll) && hpos == XFASTINT (w->left)
505:
506: /* Give up if cursor outside window (in minibuf, probably) */
507: || cursY < XFASTINT (w->top)
508: || cursY >= XFASTINT (w->top) + XFASTINT (w->height)
509:
510: /* Give up if cursor not really at cursX, cursY */
511: || !display_completed
512:
513: /* Give up if w is minibuffer and a message is being displayed there */
514: || EQ (selected_window, minibuf_window) && minibuf_message)
515: return 0;
516:
517: p->body[hpos] = c;
518: unchanged_modified = bf_modified;
519: beg_unchanged = bf_s1;
520: XFASTINT (w->last_point) = point;
521: XFASTINT (w->last_point_x) = cursX;
522: XFASTINT (w->last_modified) = bf_modified;
523:
524: reassert_line_highlight (0, cursY);
525: write_chars (p->body + hpos, 1);
526: fflush (stdout);
527: ++cursX;
528: p->length = max (p->length, cursX);
529: p->body[p->length] = 0;
530: return 1;
531: }
532:
533: int
534: direct_output_forward_char (n)
535: int n;
536: {
537: register struct window *w = XWINDOW (selected_window);
538:
539: /* Avoid losing if cursor is in invisible text off left margin */
540: if (XINT (w->hscroll) && cursX == XFASTINT (w->left))
541: return 0;
542:
543: cursX += n;
544: XFASTINT (w->last_point_x) = cursX;
545: XFASTINT (w->last_point) = point;
546: topos (cursY, cursX);
547: fflush (stdout);
548: return 1;
549: }
550:
551: /* Update the actual terminal screen based on the data in DesiredScreen.
552: Value is nonzero if redisplay stopped due to pending input.
553: FORCE nonzero means do not stop for pending input. */
554:
555: /* At the time this function is called,
556: no line is common to PhysScreen and DesiredScreen.
557: That is true again when this function returns. */
558:
559: update_screen (force, inhibit_hairy_id)
560: int force;
561: int inhibit_hairy_id;
562: {
563: register struct display_line **p;
564: register struct display_line *l, *lnew;
565: register int i;
566: int pause;
567: int preempt_count;
568: extern input_pending;
569:
570: if (screen_height == 0) abort (); /* Some bug zeros some core */
571:
572: bcopy (PhysScreen, OPhysScreen, sizeof PhysScreen);
573:
574: detect_input_pending ();
575: if (input_pending && !force)
576: {
577: pause = 1;
578: goto do_pause;
579: }
580:
581: update_begin ();
582:
583: if (!line_ins_del_ok)
584: inhibit_hairy_id = 1;
585:
586: /* Don't compute for i/d line if just want cursor motion. */
587: for (p = &DesiredScreen[screen_height]; p != DesiredScreen && *p == 0; p--);
588:
589: /* Try doing i/d line, if not yet inhibited. */
590: if (!inhibit_hairy_id && p != DesiredScreen)
591: force |= scrolling ();
592:
593: /* Update the individual lines as needed. Do bottom line first. */
594:
595: l = DesiredScreen[screen_height];
596: if (l && l != PhysScreen[screen_height])
597: update_line (PhysScreen[screen_height], l, screen_height - 1);
598: preempt_count = baud_rate / 2400;
599: for (i = 1; i < screen_height && (force || !input_pending); i++)
600: {
601: l = PhysScreen[i];
602: lnew = DesiredScreen[i];
603: if (lnew && lnew != l)
604: {
605: /* Flush out every so many lines.
606: Also flush out if likely to have more than 1k buffered
607: otherwise. I'm told that telnet connections get really
608: screwed by more than 1k output at once. */
609: int outq = PENDING_OUTPUT_COUNT (stdout);
610: if (outq > ((--preempt_count < 0) ? 20 : 900))
611: {
612: fflush (stdout);
613: if (baud_rate < 2400)
614: {
615: #ifdef TIOCOUTQ
616: if (ioctl (0, TIOCOUTQ, &outq) < 0)
617: /* Probably not a tty. Ignore the error and reset
618: * the outq count. */
619: outq = PENDING_OUTPUT_COUNT (stdout);
620: #endif
621: outq *= 10;
622: outq /= baud_rate; /* outq is now in seconds */
623: if (outq)
624: sleep (outq);
625: }
626: detect_input_pending ();
627:
628: preempt_count = baud_rate / 2400;
629: }
630: /* Now update this line. */
631: update_line (l, lnew, i - 1);
632: }
633: }
634: pause = (i < screen_height) ? i : 0;
635:
636: /* Now just clean up termcap drivers and set cursor, etc. */
637: if (!pause)
638: {
639: if (cursor_in_echo_area < 0)
640: topos (screen_height - 1, 0);
641: else if (cursor_in_echo_area)
642: topos (screen_height - 1,
643: (PhysScreen[screen_height] == 0 ? 0
644: : min (screen_width - 1,
645: PhysScreen[screen_height]->length)));
646: else
647: topos (cursY, max (min (cursX, screen_width - 1), 0));
648: }
649:
650: update_end ();
651:
652: if (termscript)
653: fflush (termscript);
654: fflush (stdout);
655:
656: /* Here if output is preempted because input is detected. */
657: do_pause:
658:
659: if (screen_height == 0) abort (); /* Some bug zeros some core */
660: display_completed = !pause;
661: /* Free any lines still in desired screen but not in phys screen */
662: /* Free any lines that used to be in phys screen but are no longer */
663: for (p = &PhysScreen[screen_height]; p != PhysScreen; p--)
664: if (p[0]) p[0]->physical = 1;
665: for (p = &DesiredScreen[screen_height]; p != DesiredScreen; p--)
666: {
667: if (l = *p)
668: {
669: if (!l->physical)
670: {
671: return_display_line (l);
672: /* Prevent line in both DesiredScreen and OPhysScreen
673: from being freed twice. */
674: l->physical = 1;
675: }
676: }
677: }
678: for (p = &OPhysScreen[screen_height]; p != OPhysScreen; p--)
679: {
680: if (l = *p)
681: {
682: if (!l->physical)
683: return_display_line (l);
684: }
685: }
686: i = 0;
687: for (p = &PhysScreen[screen_height]; p != PhysScreen; p--)
688: if (p[0])
689: {
690: i++;
691: p[0]->physical = 0;
692: }
693:
694: {
695: extern int debug_end_pos;
696: if (debug_end_pos && i + free_line_count != 2 * screen_height)
697: abort ();
698: }
699:
700: bzero (OPhysScreen, (screen_height + 1) * sizeof OPhysScreen[0]);
701: bzero (DesiredScreen, (screen_height + 1) * sizeof DesiredScreen[0]);
702: return pause;
703: }
704:
705: /* Called when about to quit, to check for doing so
706: at an improper time. */
707:
708: void
709: quit_error_check ()
710: {
711: if (DesiredScreen[1] != 0)
712: abort ();
713: if (DesiredScreen[screen_height] != 0)
714: abort ();
715: }
716:
717: /* Decide what insert/delete line to do, and do it */
718:
719: scrolling ()
720: {
721: int unchanged_at_top, unchanged_at_bottom;
722: int window_size;
723: int changed_lines;
724: int *old_hash = (int *) alloca (screen_height * sizeof (int));
725: int *new_hash = (int *) alloca (screen_height * sizeof (int));
726: int *draw_cost = (int *) alloca (screen_height * sizeof (int));
727: register int i;
728: int free_at_end_vpos = screen_height;
729:
730: /* Compute hash codes of all the lines.
731: Also calculate number of changed lines,
732: number of unchanged lines at the beginning,
733: and number of unchanged lines at the end. */
734:
735: changed_lines = 0;
736: unchanged_at_top = 0;
737: unchanged_at_bottom = screen_height;
738: for (i = 0; i < screen_height; i++)
739: {
740: old_hash[i] = line_hash_code (PhysScreen[i + 1]);
741: if (!DesiredScreen[i + 1])
742: DesiredScreen[i + 1] = PhysScreen[i + 1];
743: if (PhysScreen[i + 1] == DesiredScreen[i + 1])
744: new_hash[i] = old_hash[i];
745: else
746: new_hash[i] = line_hash_code (DesiredScreen[i + 1]);
747: if (old_hash[i] != new_hash[i])
748: {
749: changed_lines++;
750: unchanged_at_bottom = screen_height - i - 1;
751: }
752: else if (i == unchanged_at_top)
753: unchanged_at_top++;
754: draw_cost[i] = line_draw_cost (DesiredScreen[i + 1]);
755: }
756:
757: /* If changed lines are few, don't allow preemption, don't scroll. */
758: if (changed_lines < baud_rate / 2400 || unchanged_at_bottom == screen_height)
759: return 1;
760:
761: window_size = screen_height - unchanged_at_top - unchanged_at_bottom;
762:
763: if (scroll_region_ok)
764: free_at_end_vpos -= unchanged_at_bottom;
765: else if (memory_below_screen)
766: free_at_end_vpos = -1;
767:
768: /* If large window, fast terminal and few lines in common between
769: PhysScreen and DesiredScreen, don't bother with i/d calc. */
770: if (window_size >= 18 && baud_rate > 2400
771: && (window_size >=
772: 10 * scrolling_max_lines_saved (unchanged_at_top,
773: screen_height - unchanged_at_bottom,
774: old_hash, new_hash, draw_cost)))
775: return 0;
776:
777: scrolling_1 (window_size, unchanged_at_top, unchanged_at_bottom,
778: draw_cost + unchanged_at_top - 1,
779: old_hash + unchanged_at_top - 1,
780: new_hash + unchanged_at_top - 1,
781: free_at_end_vpos - unchanged_at_top);
782:
783: return 0;
784: }
785:
786: update_line (old, new, vpos)
787: struct display_line *old, *new;
788: int vpos;
789: {
790: register char *obody, *nbody, *op1, *op2, *np1;
791: int tem;
792: int osp, nsp, m1, m2, olen, nlen;
793: int save;
794:
795: if (old == new)
796: return;
797:
798: /* Mark physical screen as containing the line `new' */
799: PhysScreen[vpos + 1] = new;
800:
801: if ((new && new->highlighted) != (old && old->highlighted))
802: {
803: change_line_highlight (new && new->highlighted, vpos, old ? old->length : 0);
804: old = 0;
805: }
806: else
807: reassert_line_highlight (new && new->highlighted, vpos);
808:
809: if (!old)
810: {
811: olen = 0;
812: }
813: else
814: {
815: obody = old -> body;
816: olen = old->length;
817: if (! old->highlighted)
818: {
819: /* Note obody[-1] is old->physical, which is always 0 or 1. */
820: if (!must_write_spaces)
821: while (obody[olen - 1] == ' ')
822: olen--;
823: }
824: else
825: {
826: /* For an inverse-video line, remember we gave it
827: spaces all the way to the screen edge
828: so that the reverse video extends all the way across. */
829: while (olen < screen_width - 1)
830: obody[olen++] = ' ';
831: }
832: }
833:
834: if (!new)
835: {
836: nlen = 0;
837: goto just_erase;
838: }
839:
840: nbody = new -> body;
841: nlen = new->length;
842:
843: /* Pretend trailing spaces are not there at all,
844: unless for one reason or another we must write all spaces. */
845: /* We know that the previous character is the `physical' field
846: and it is zero or one. */
847: if (! new->highlighted)
848: {
849: if (!must_write_spaces)
850: while (nbody[nlen - 1] == ' ')
851: nlen--;
852: }
853: else
854: {
855: /* For an inverse-video line, give it extra trailing spaces
856: all the way to the screen edge
857: so that the reverse video extends all the way across. */
858: while (nlen < screen_width - 1)
859: nbody[nlen++] = ' ';
860: }
861:
862: /* If there's no i/d char, quickly do the best we can without it. */
863: if (!char_ins_del_ok)
864: {
865: int i,j;
866:
867: for (i = 0; i < nlen; i++)
868: {
869: if (i >= olen || nbody[i] != obody[i])
870: {
871: /* We found a non-matching char. */
872: topos (vpos, i);
873: for (j = 1; (i + j < nlen &&
874: (i + j >= olen || nbody[i+j] != obody[i+j]));
875: j++);
876: /* Output this run of non-matching chars. */
877: write_chars (nbody + i, j);
878: i += j - 1;
879: /* Now find the next non-match. */
880: }
881: }
882: /* Clear the rest of the line, or the non-clear part of it. */
883: if (olen > nlen)
884: {
885: topos (vpos, nlen);
886: clear_end_of_line (olen);
887: }
888: return;
889: }
890:
891: if (!olen)
892: {
893: nsp = (must_write_spaces || new->highlighted)
894: ? 0 : count_blanks (nbody);
895: if (nlen > nsp)
896: {
897: topos (vpos, nsp);
898: write_chars (nbody + nsp, nlen - nsp);
899: }
900: return;
901: }
902:
903: obody[olen] = 1;
904: save = nbody[nlen];
905: nbody[nlen] = 0;
906:
907: /* Compute number of leading blanks in old and new contents. */
908: osp = count_blanks (obody);
909: if (!new->highlighted)
910: nsp = count_blanks (nbody);
911: else
912: nsp = 0;
913:
914: /* Compute number of matching chars starting with first nonblank. */
915: m1 = count_match (obody + osp, nbody + nsp);
916:
917: /* Spaces in new match implicit space past the end of old. */
918: /* A bug causing this to be a no-op was fixed in 18.29. */
919: if (!must_write_spaces && osp + m1 == olen)
920: {
921: np1 = nbody + nsp;
922: while (np1[m1] == ' ')
923: m1++;
924: }
925:
926: /* Avoid doing insert/delete char
927: just cause number of leading spaces differs
928: when the following text does not match. */
929: if (m1 == 0 && osp != nsp)
930: osp = nsp = min (osp, nsp);
931:
932: /* Find matching characters at end of line */
933: op1 = obody + olen;
934: np1 = nbody + nlen;
935: op2 = op1 + m1 - min (olen - osp, nlen - nsp);
936: while (op1 > op2 && op1[-1] == np1[-1])
937: {
938: op1--;
939: np1--;
940: }
941: m2 = obody + olen - op1;
942:
943: /* Put correct value back in nbody[nlen].
944: This is important because direct_output_for_insert
945: can write into the line at a later point. */
946: nbody[nlen] = save;
947:
948: /* tem gets the distance to insert or delete.
949: m2 is how many characters we save by doing so.
950: Is it worth it? */
951:
952: tem = (nlen - nsp) - (olen - osp);
953: if (m2 && tem && m2 <= DCICcost[tem])
954: m2 = 0;
955:
956: /* nsp - osp is the distance to insert or delete.
957: m1 + m2 is how much we save by doing so.
958: Is it worth it? */
959:
960: if (m1 + m2 && nsp != osp && m1 + m2 <= DCICcost[nsp - osp])
961: {
962: m1 = 0;
963: m2 = 0;
964: osp = nsp = min (osp, nsp);
965: }
966:
967: /* Now go through the line, inserting, writing and deleting as appropriate. */
968:
969: if (osp > nsp)
970: {
971: topos (vpos, nsp);
972: delete_chars (osp - nsp);
973: }
974: else if (nsp > osp)
975: {
976: /* If going to delete chars later in line
977: and insert earlier in the line,
978: must delete first to avoid losing data in the insert */
979: if (m2 && nlen < olen + nsp - osp)
980: {
981: topos (vpos, nlen - m2 + osp - nsp);
982: delete_chars (olen + nsp - osp - nlen);
983: olen = nlen - (nsp - osp);
984: }
985: topos (vpos, osp);
986: insert_chars ((char *)0, nsp - osp);
987: }
988: olen += nsp - osp;
989:
990: tem = nsp + m1 + m2;
991: if (nlen != tem || olen != tem)
992: {
993: topos (vpos, nsp + m1);
994: if (!m2 || nlen == olen)
995: {
996: /* If new text being written reaches right margin,
997: there is no need to do clear-to-eol at the end.
998: (and it would not be safe, since cursor is not
999: going to be "at the margin" after the text is done) */
1000: if (nlen == screen_width)
1001: olen = 0;
1002: write_chars (nbody + nsp + m1, nlen - tem);
1003: #ifdef obsolete
1004: /* the following code loses disastrously if tem == nlen.
1005: Rather than trying to fix that case, I am trying the simpler
1006: solution found above. */
1007: /* If the text reaches to the right margin,
1008: it will lose one way or another (depending on AutoWrap)
1009: to clear to end of line after outputting all the text.
1010: So pause with one character to go and clear the line then. */
1011: if (nlen == screen_width && fast_clear_end_of_line && olen > nlen)
1012: {
1013: /* m2 must be zero, and tem must equal nsp + m1 */
1014: write_chars (nbody + tem, nlen - tem - 1);
1015: clear_end_of_line (olen);
1016: olen = 0; /* Don't let it be cleared again later */
1017: write_chars (nbody + nlen - 1, 1);
1018: }
1019: else
1020: write_chars (nbody + nsp + m1, nlen - tem);
1021: #endif
1022: }
1023: else if (nlen > olen)
1024: {
1025: write_chars (nbody + nsp + m1, olen - tem);
1026: insert_chars (nbody + nsp + m1 + olen - tem, nlen - olen);
1027: olen = nlen;
1028: }
1029: else if (olen > nlen)
1030: {
1031: write_chars (nbody + nsp + m1, nlen - tem);
1032: delete_chars (olen - nlen);
1033: olen = nlen;
1034: }
1035: }
1036:
1037: just_erase:
1038: /* If any unerased characters remain after the new line, erase them. */
1039: if (olen > nlen)
1040: {
1041: topos (vpos, nlen);
1042: clear_end_of_line (olen);
1043: }
1044: }
1045:
1046: count_blanks (str)
1047: char *str;
1048: {
1049: register char *p = str;
1050: while (*str++ == ' ');
1051: return str - p - 1;
1052: }
1053:
1054: count_match (str1, str2)
1055: char *str1, *str2;
1056: {
1057: register char *p1 = str1;
1058: register char *p2 = str2;
1059: while (*p1++ == *p2++);
1060: return p1 - str1 - 1;
1061: }
1062:
1063: DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
1064: 1, 1, "FOpen termscript file: ",
1065: "Start writing all terminal output to FILE as well as the terminal.\n\
1066: FILE = nil means just close any termscript file currently open.")
1067: (file)
1068: Lisp_Object file;
1069: {
1070: if (termscript != 0) fclose (termscript);
1071: termscript = 0;
1072:
1073: if (! NULL (file))
1074: {
1075: file = Fexpand_file_name (file, Qnil);
1076: termscript = fopen (XSTRING (file)->data, "w");
1077: if (termscript == 0)
1078: report_file_error ("Opening termscript", Fcons (file, Qnil));
1079: }
1080: return Qnil;
1081: }
1082:
1083: DEFUN ("set-screen-height", Fset_screen_height, Sset_screen_height, 1, 2, 0,
1084: "Tell redisplay that the screen has LINES lines.\n\
1085: Optional second arg non-nil means that redisplay should use LINES lines\n\
1086: but that the idea of the actual height of the screen should not be changed.")
1087: (n, pretend)
1088: Lisp_Object n, pretend;
1089: {
1090: CHECK_NUMBER (n, 0);
1091: change_screen_size (XINT (n), 0, !NULL (pretend));
1092: return Qnil;
1093: }
1094:
1095: DEFUN ("set-screen-width", Fset_screen_width, Sset_screen_width, 1, 2, 0,
1096: "Tell redisplay that the screen has COLS columns.\n\
1097: Optional second arg non-nil means that redisplay should use COLS columns\n\
1098: but that the idea of the actual width of the screen should not be changed.")
1099: (n, pretend)
1100: Lisp_Object n, pretend;
1101: {
1102: CHECK_NUMBER (n, 0);
1103: change_screen_size (0, XINT (n), !NULL (pretend));
1104: return Qnil;
1105: }
1106:
1107: DEFUN ("screen-height", Fscreen_height, Sscreen_height, 0, 0, 0,
1108: "Return number of lines on screen available for display.")
1109: ()
1110: {
1111: return make_number (screen_height);
1112: }
1113:
1114: DEFUN ("screen-width", Fscreen_width, Sscreen_width, 0, 0, 0,
1115: "Return number of columns on screen available for display.")
1116: ()
1117: {
1118: return make_number (screen_width);
1119: }
1120:
1121: #ifdef SIGWINCH
1122: window_change_signal ()
1123: {
1124: int width, height;
1125: extern int errno;
1126: int old_errno = errno;
1127:
1128: get_screen_size (&width, &height);
1129: change_screen_size (height, width, 0);
1130: signal (SIGWINCH, window_change_signal);
1131:
1132: errno = old_errno;
1133: }
1134: #endif /* SIGWINCH */
1135:
1136: /* Prevent screen size from being changed by signals. */
1137: hold_window_change ()
1138: {
1139: in_display = 1;
1140: }
1141:
1142: /* Reenable signals to change the screen size
1143: and handle any signals that have happened already. */
1144:
1145: unhold_window_change ()
1146: {
1147: in_display = 0;
1148: /* If change_screen_size should have run before, run it now. */
1149: while (delayed_size_change)
1150: {
1151: int newwidth = delayed_screen_width;
1152: int newheight = delayed_screen_height;
1153: delayed_size_change = 0;
1154: in_display = 1;
1155: change_screen_size_1 (newheight, newwidth, 0);
1156: in_display = 0;
1157: }
1158: }
1159:
1160: /* Change the screen height and/or width. Values may be given as zero to
1161: indicate no change is to take place.
1162: PRETEND is normally 0; 1 means change used-size only
1163: but don't change the size used for calculations;
1164: -1 means don't redisplay. */
1165:
1166: change_screen_size (newlength, newwidth, pretend)
1167: register int newlength, newwidth, pretend;
1168: {
1169: /* If we can't deal with the change now, queue it for later. */
1170: if (in_display)
1171: {
1172: delayed_screen_width = newwidth;
1173: delayed_screen_height = newlength;
1174: delayed_size_change = 1;
1175: return;
1176: }
1177: delayed_size_change = 0;
1178: change_screen_size_1 (newlength, newwidth, pretend);
1179: }
1180:
1181: change_screen_size_1 (newlength, newwidth, pretend)
1182: register int newlength, newwidth, pretend;
1183: {
1184: if ((newlength == 0 || newlength == screen_height)
1185: && (newwidth == 0 || newwidth == screen_width))
1186: return;
1187: if (newlength && newlength != screen_height)
1188: {
1189: if (newlength > MScreenLength)
1190: newlength = MScreenLength;
1191: set_window_height (XWINDOW (minibuf_window)->prev, newlength - 1, 0);
1192: XFASTINT (XWINDOW (minibuf_window)->top) = newlength - 1;
1193: set_window_height (minibuf_window, 1, 0);
1194: screen_height = newlength;
1195: if (pretend <= 0)
1196: ScreenRows = newlength;
1197: set_terminal_window (0);
1198: }
1199: if (newwidth && newwidth != screen_width)
1200: {
1201: if (newwidth > MScreenWidth)
1202: newwidth = MScreenWidth;
1203: set_window_width (XWINDOW (minibuf_window)->prev, newwidth, 0);
1204: set_window_width (minibuf_window, newwidth, 0);
1205: screen_width = newwidth;
1206: if (pretend <= 0)
1207: ScreenCols = newwidth;
1208: }
1209: make_display_lines ();
1210: calculate_costs ();
1211: if (pretend >= 0)
1212: DoDsp (1);
1213: }
1214:
1215: DEFSIMPLE ("baud-rate", Fbaud_rate, Sbaud_rate,
1216: "Return the output baud rate of the terminal.",
1217: Lisp_Int, XSETINT, baud_rate)
1218:
1219: DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
1220: Ssend_string_to_terminal, 1, 1, 0,
1221: "Send STRING to the terminal without alteration.\n\
1222: Control characters in STRING will have terminal-dependent effects.")
1223: (str)
1224: Lisp_Object str;
1225: {
1226: CHECK_STRING (str, 0);
1227: fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, stdout);
1228: fflush (stdout);
1229: if (termscript)
1230: {
1231: fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, termscript);
1232: fflush (termscript);
1233: }
1234: return Qnil;
1235: }
1236:
1237: DEFUN ("ding", Fding, Sding, 0, 1, 0,
1238: "Beep, or flash the screen.\n\
1239: Terminates any keyboard macro currently executing unless an argument\n\
1240: is given.")
1241: (arg)
1242: Lisp_Object arg;
1243: {
1244: if (!NULL (arg))
1245: {
1246: ring_bell ();
1247: fflush (stdout);
1248: }
1249: else
1250: Ding ();
1251: return Qnil;
1252: }
1253:
1254: Ding ()
1255: {
1256: if (noninteractive)
1257: putchar (07);
1258: else if (!INTERACTIVE) /* Stop executing a keyboard macro. */
1259: error ("Keyboard macro terminated by a command ringing the bell");
1260: else
1261: ring_bell ();
1262: fflush (stdout);
1263: }
1264:
1265: DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 1, 0,
1266: "Pause, without updating display, for ARG seconds.")
1267: (n)
1268: Lisp_Object n;
1269: {
1270: register int t;
1271: #ifndef subprocesses
1272: #ifdef HAVE_TIMEVAL
1273: struct timeval timeout, end_time, garbage1;
1274: #endif /* HAVE_TIMEVAL */
1275: #endif /* no subprocesses */
1276:
1277: CHECK_NUMBER (n, 0);
1278: t = XINT (n);
1279: if (t <= 0)
1280: return Qnil;
1281:
1282: #ifdef subprocesses
1283: wait_reading_process_input (t, 0, 0);
1284: #else /* No subprocesses */
1285: immediate_quit = 1;
1286: QUIT;
1287:
1288: #ifdef VMS
1289: sys_sleep (t);
1290: #else /* not VMS */
1291: /* The reason this is done this way
1292: (rather than defined (H_S) && defined (H_T))
1293: is because the VMS preprocessor doesn't grok `defined' */
1294: #ifdef HAVE_SELECT
1295: #ifdef HAVE_TIMEVAL
1296: gettimeofday (&end_time, &garbage1);
1297: end_time.tv_sec += t;
1298:
1299: while (1)
1300: {
1301: gettimeofday (&timeout, &garbage1);
1302: timeout.tv_sec = end_time.tv_sec - timeout.tv_sec;
1303: timeout.tv_usec = end_time.tv_usec - timeout.tv_usec;
1304: if (timeout.tv_usec < 0)
1305: timeout.tv_usec += 1000000,
1306: timeout.tv_sec--;
1307: if (timeout.tv_sec < 0)
1308: break;
1309: if (!select (1, 0, 0, 0, &timeout))
1310: break;
1311: }
1312: #else /* not HAVE_TIMEVAL */
1313: /* Is it safe to quit out of `sleep'? I'm afraid to trust it. */
1314: sleep (t);
1315: #endif /* HAVE_TIMEVAL */
1316: #else /* not HAVE_SELECT */
1317: sleep (t);
1318: #endif /* HAVE_SELECT */
1319: #endif /* not VMS */
1320:
1321: immediate_quit = 0;
1322: #endif /* no subprocesses */
1323: return Qnil;
1324: }
1325:
1326: DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 2, 0,
1327: "Perform redisplay, then wait for ARG seconds or until input is available.\n\
1328: Optional second arg non-nil means don't redisplay.\n\
1329: Redisplay is preempted as always if input arrives, and does not happen\n\
1330: if input is available before it starts.\n\
1331: Value is t if waited the full time with no input arriving.")
1332: (n, nodisp)
1333: Lisp_Object n, nodisp;
1334: {
1335: #ifndef subprocesses
1336: #ifdef HAVE_TIMEVAL
1337: struct timeval timeout;
1338: #else
1339: int timeout_sec;
1340: #endif
1341: int waitchannels;
1342: #endif /* no subprocesses */
1343:
1344: CHECK_NUMBER (n, 0);
1345:
1346: if (detect_input_pending ())
1347: return Qnil;
1348:
1349: if (EQ (nodisp, Qnil))
1350: DoDsp (1); /* Make the screen correct */
1351: if (XINT (n) > 0)
1352: {
1353: #ifdef subprocesses
1354: #ifdef SIGIO
1355: gobble_input ();
1356: #endif /* SIGIO */
1357: wait_reading_process_input (XINT (n), 1, 1);
1358: #else /* no subprocesses */
1359: immediate_quit = 1;
1360: QUIT;
1361:
1362: waitchannels = 1;
1363: #ifdef VMS
1364: input_wait_timeout (XINT (n));
1365: #else /* not VMS */
1366: #ifndef HAVE_TIMEVAL
1367: timeout_sec = XINT (n);
1368: select (1, &waitchannels, 0, 0, &timeout_sec);
1369: #else /* HAVE_TIMEVAL */
1370: timeout.tv_sec = XINT (n);
1371: timeout.tv_usec = 0;
1372: select (1, &waitchannels, 0, 0, &timeout);
1373: #endif /* HAVE_TIMEVAL */
1374: #endif /* not VMS */
1375:
1376: immediate_quit = 0;
1377: #endif /* no subprocesses */
1378: }
1379: return detect_input_pending () ? Qnil : Qt;
1380: }
1381:
1382: char *terminal_type;
1383:
1384: /* Initialization done when Emacs fork is started, before doing stty. */
1385: /* Determine terminal type and set terminal_driver */
1386: /* Then invoke its decoding routine to set up variables
1387: in the terminal package */
1388:
1389: init_display ()
1390: {
1391: #ifdef HAVE_X_WINDOWS
1392: extern Lisp_Object Vxterm;
1393: Vxterm = Qnil;
1394: #endif
1395:
1396: Vwindow_system = Qnil;
1397: MetaFlag = 0;
1398: inverse_video = 0;
1399: cursor_in_echo_area = 0;
1400: terminal_type = (char *) 0;
1401:
1402: if (!inhibit_window_system)
1403: {
1404: #ifdef HAVE_X_WINDOWS
1405: extern char *alternate_display;
1406: char *disp = egetenv ("DISPLAY");
1407:
1408: /* Note KSH likes to provide an empty string as an envvar value. */
1409: if (alternate_display || (disp && *disp))
1410: {
1411: x_term_init ();
1412: Vxterm = Qt;
1413: Vwindow_system = intern ("x");
1414: #ifdef X11
1415: Vwindow_system_version = make_number (11);
1416: #else
1417: Vwindow_system_version = make_number (10);
1418: #endif
1419: goto term_init_done;
1420: }
1421: #endif /* HAVE_X_WINDOWS */
1422: ;
1423: }
1424: /* Record we aren't using a window system. */
1425: inhibit_window_system = 1;
1426:
1427: /* Look at the TERM variable */
1428: terminal_type = (char *) getenv ("TERM");
1429: if (!terminal_type)
1430: {
1431: #ifdef VMS
1432: fprintf (stderr, "Please specify your terminal type.\n\
1433: For types defined in VMS, use set term /device=TYPE.\n\
1434: For types not defined in VMS, use define emacs_term \"TYPE\".\n\
1435: \(The quotation marks are necessary since terminal types are lower case.)\n");
1436: #else
1437: fprintf (stderr, "Please set the environment variable TERM; see tset(1).\n");
1438: #endif
1439: exit (1);
1440: }
1441: term_init (terminal_type);
1442:
1443: term_init_done:
1444: make_display_lines ();
1445:
1446: cursX = 0; /* X and Y coordinates of the cursor */
1447: cursY = 0; /* between updates. */
1448:
1449: #ifdef SIGWINCH
1450: #ifndef CANNOT_DUMP
1451: if (initialized)
1452: #endif /* CANNOT_DUMP */
1453: if (inhibit_window_system)
1454: signal (SIGWINCH, window_change_signal);
1455: #endif /* SIGWINCH */
1456: }
1457:
1458: syms_of_display ()
1459: {
1460: defsubr (&Sopen_termscript);
1461: defsubr (&Sding);
1462: defsubr (&Ssit_for);
1463: defsubr (&Sscreen_height);
1464: defsubr (&Sscreen_width);
1465: defsubr (&Sset_screen_height);
1466: defsubr (&Sset_screen_width);
1467: defsubr (&Ssleep_for);
1468: defsubr (&Sbaud_rate);
1469: defsubr (&Ssend_string_to_terminal);
1470:
1471: DEFVAR_BOOL ("inverse-video", &inverse_video,
1472: "*Non-nil means use inverse-video.");
1473: DEFVAR_BOOL ("visible-bell", &visible_bell,
1474: "*Non-nil means try to flash the screen to represent a bell.");
1475: DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter,
1476: "*Non-nil means no need to redraw entire screen after suspending.\n\
1477: It is up to you to set this variable to inform Emacs.");
1478: DEFVAR_LISP ("window-system", &Vwindow_system,
1479: "A symbol naming the window-system under which Emacs is running,\n\
1480: \(such as `x'), or nil if emacs is running on an ordinary terminal.");
1481: DEFVAR_LISP ("window-system-version", &Vwindow_system_version,
1482: "Version number of the window system Emacs is running under.");
1483: Vwindow_system_version = Qnil;
1484: DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area,
1485: "Non-nil means put cursor in minibuffer after any message displayed there.");
1486:
1487: /* Initialize `window-system', unless init_display already decided it. */
1488: #ifdef CANNOT_DUMP
1489: if (noninteractive)
1490: #endif
1491: Vwindow_system = Qnil;
1492: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.