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