Checked trouble.texi.
[emacs.git] / src / w32console.c
blob947ff7554fc4b515311f579f71ce18323a16b8d7
1 /* Terminal hooks for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1992, 1999, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 Tim Fleehart (apollo@online.com) 1-17-92
22 Geoff Voelker (voelker@cs.washington.edu) 9-12-93
26 #include <config.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <windows.h>
31 #include <string.h>
33 #include "lisp.h"
34 #include "character.h"
35 #include "coding.h"
36 #include "disptab.h"
37 #include "frame.h"
38 #include "termhooks.h"
39 #include "termchar.h"
40 #include "dispextern.h"
41 #include "w32inevt.h"
43 /* from window.c */
44 extern Lisp_Object Frecenter ();
46 /* from keyboard.c */
47 extern int detect_input_pending ();
49 /* from sysdep.c */
50 extern int read_input_pending ();
52 static void w32con_move_cursor (struct frame *f, int row, int col);
53 static void w32con_clear_to_end (struct frame *f);
54 static void w32con_clear_frame (struct frame *f);
55 static void w32con_clear_end_of_line (struct frame *f, int);
56 static void w32con_ins_del_lines (struct frame *f, int vpos, int n);
57 static void w32con_insert_glyphs (struct frame *f, struct glyph *start, int len);
58 static void w32con_write_glyphs (struct frame *f, struct glyph *string, int len);
59 static void w32con_delete_glyphs (struct frame *f, int n);
60 static void w32con_reset_terminal_modes (struct terminal *t);
61 static void w32con_set_terminal_modes (struct terminal *t);
62 static void w32con_set_terminal_window (struct frame *f, int size);
63 static void w32con_update_begin (struct frame * f);
64 static void w32con_update_end (struct frame * f);
65 static WORD w32_face_attributes (struct frame *f, int face_id);
67 static COORD cursor_coords;
68 static HANDLE prev_screen, cur_screen;
69 static WORD char_attr_normal;
70 static DWORD prev_console_mode;
72 #ifndef USE_SEPARATE_SCREEN
73 static CONSOLE_CURSOR_INFO prev_console_cursor;
74 #endif
76 extern Lisp_Object Vtty_defined_color_alist;
78 /* Determine whether to make frame dimensions match the screen buffer,
79 or the current window size. The former is desirable when running
80 over telnet, while the latter is more useful when working directly at
81 the console with a large scroll-back buffer. */
82 int w32_use_full_screen_buffer;
83 HANDLE keyboard_handle;
86 /* Setting this as the ctrl handler prevents emacs from being killed when
87 someone hits ^C in a 'suspended' session (child shell).
88 Also ignore Ctrl-Break signals. */
90 BOOL
91 ctrl_c_handler (unsigned long type)
93 /* Only ignore "interrupt" events when running interactively. */
94 return (!noninteractive
95 && (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT));
99 /* Move the cursor to (ROW, COL) on FRAME. */
100 static void
101 w32con_move_cursor (struct frame *f, int row, int col)
103 cursor_coords.X = col;
104 cursor_coords.Y = row;
106 /* TODO: for multi-tty support, cur_screen should be replaced with a
107 reference to the terminal for this frame. */
108 SetConsoleCursorPosition (cur_screen, cursor_coords);
111 /* Clear from cursor to end of screen. */
112 static void
113 w32con_clear_to_end (struct frame *f)
115 w32con_clear_end_of_line (f, FRAME_COLS (f) - 1);
116 w32con_ins_del_lines (f, cursor_coords.Y, FRAME_LINES (f) - cursor_coords.Y - 1);
119 /* Clear the frame. */
120 static void
121 w32con_clear_frame (struct frame *f)
123 COORD dest;
124 int n;
125 DWORD r;
126 CONSOLE_SCREEN_BUFFER_INFO info;
128 GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info);
130 /* Remember that the screen buffer might be wider than the window. */
131 n = FRAME_LINES (f) * info.dwSize.X;
132 dest.X = dest.Y = 0;
134 FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
135 FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
137 w32con_move_cursor (f, 0, 0);
141 static struct glyph glyph_base[256];
142 static BOOL ceol_initialized = FALSE;
144 /* Clear from Cursor to end (what's "standout marker"?). */
145 static void
146 w32con_clear_end_of_line (struct frame *f, int end)
148 if (!ceol_initialized)
150 int i;
151 for (i = 0; i < 256; i++)
153 memcpy (&glyph_base[i], &space_glyph, sizeof (struct glyph));
155 ceol_initialized = TRUE;
157 w32con_write_glyphs (f, glyph_base, end - cursor_coords.X); /* fencepost ? */
160 /* Insert n lines at vpos. if n is negative delete -n lines. */
161 static void
162 w32con_ins_del_lines (struct frame *f, int vpos, int n)
164 int i, nb;
165 SMALL_RECT scroll;
166 SMALL_RECT clip;
167 COORD dest;
168 CHAR_INFO fill;
170 if (n < 0)
172 scroll.Top = vpos - n;
173 scroll.Bottom = FRAME_LINES (f);
174 dest.Y = vpos;
176 else
178 scroll.Top = vpos;
179 scroll.Bottom = FRAME_LINES (f) - n;
180 dest.Y = vpos + n;
182 clip.Top = clip.Left = scroll.Left = 0;
183 clip.Right = scroll.Right = FRAME_COLS (f);
184 clip.Bottom = FRAME_LINES (f);
186 dest.X = 0;
188 fill.Char.AsciiChar = 0x20;
189 fill.Attributes = char_attr_normal;
191 ScrollConsoleScreenBuffer (cur_screen, &scroll, &clip, dest, &fill);
193 /* Here we have to deal with a w32 console flake: If the scroll
194 region looks like abc and we scroll c to a and fill with d we get
195 cbd... if we scroll block c one line at a time to a, we get cdd...
196 Emacs expects cdd consistently... So we have to deal with that
197 here... (this also occurs scrolling the same way in the other
198 direction. */
200 if (n > 0)
202 if (scroll.Bottom < dest.Y)
204 for (i = scroll.Bottom; i < dest.Y; i++)
206 w32con_move_cursor (f, i, 0);
207 w32con_clear_end_of_line (f, FRAME_COLS (f));
211 else
213 nb = dest.Y + (scroll.Bottom - scroll.Top) + 1;
215 if (nb < scroll.Top)
217 for (i = nb; i < scroll.Top; i++)
219 w32con_move_cursor (f, i, 0);
220 w32con_clear_end_of_line (f, FRAME_COLS (f));
225 cursor_coords.X = 0;
226 cursor_coords.Y = vpos;
229 #undef LEFT
230 #undef RIGHT
231 #define LEFT 1
232 #define RIGHT 0
234 static void
235 scroll_line (struct frame *f, int dist, int direction)
237 /* The idea here is to implement a horizontal scroll in one line to
238 implement delete and half of insert. */
239 SMALL_RECT scroll, clip;
240 COORD dest;
241 CHAR_INFO fill;
243 clip.Top = scroll.Top = clip.Bottom = scroll.Bottom = cursor_coords.Y;
244 clip.Left = 0;
245 clip.Right = FRAME_COLS (f);
247 if (direction == LEFT)
249 scroll.Left = cursor_coords.X + dist;
250 scroll.Right = FRAME_COLS (f) - 1;
252 else
254 scroll.Left = cursor_coords.X;
255 scroll.Right = FRAME_COLS (f) - dist - 1;
258 dest.X = cursor_coords.X;
259 dest.Y = cursor_coords.Y;
261 fill.Char.AsciiChar = 0x20;
262 fill.Attributes = char_attr_normal;
264 ScrollConsoleScreenBuffer (cur_screen, &scroll, &clip, dest, &fill);
268 /* If start is zero insert blanks instead of a string at start ?. */
269 static void
270 w32con_insert_glyphs (struct frame *f, register struct glyph *start, register int len)
272 scroll_line (f, len, RIGHT);
274 /* Move len chars to the right starting at cursor_coords, fill with blanks */
275 if (start)
277 /* Print the first len characters of start, cursor_coords.X adjusted
278 by write_glyphs. */
280 w32con_write_glyphs (f, start, len);
282 else
284 w32con_clear_end_of_line (f, cursor_coords.X + len);
288 extern unsigned char *encode_terminal_code P_ ((struct glyph *, int,
289 struct coding_system *));
291 static void
292 w32con_write_glyphs (struct frame *f, register struct glyph *string,
293 register int len)
295 DWORD r;
296 WORD char_attr;
297 unsigned char *conversion_buffer;
298 struct coding_system *coding;
300 if (len <= 0)
301 return;
303 /* If terminal_coding does any conversion, use it, otherwise use
304 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
305 because it always return 1 if the member src_multibyte is 1. */
306 coding = (FRAME_TERMINAL_CODING (f)->common_flags & CODING_REQUIRE_ENCODING_MASK
307 ? FRAME_TERMINAL_CODING (f) : &safe_terminal_coding);
308 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
309 the tail. */
310 coding->mode &= ~CODING_MODE_LAST_BLOCK;
312 while (len > 0)
314 /* Identify a run of glyphs with the same face. */
315 int face_id = string->face_id;
316 int n;
318 for (n = 1; n < len; ++n)
319 if (string[n].face_id != face_id)
320 break;
322 /* Turn appearance modes of the face of the run on. */
323 char_attr = w32_face_attributes (f, face_id);
325 if (n == len)
326 /* This is the last run. */
327 coding->mode |= CODING_MODE_LAST_BLOCK;
328 conversion_buffer = encode_terminal_code (string, n, coding);
329 if (coding->produced > 0)
331 /* Set the attribute for these characters. */
332 if (!FillConsoleOutputAttribute (cur_screen, char_attr,
333 coding->produced, cursor_coords,
334 &r))
336 printf ("Failed writing console attributes: %d\n",
337 GetLastError ());
338 fflush (stdout);
341 /* Write the characters. */
342 if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
343 coding->produced, cursor_coords,
344 &r))
346 printf ("Failed writing console characters: %d\n",
347 GetLastError ());
348 fflush (stdout);
351 cursor_coords.X += coding->produced;
352 w32con_move_cursor (f, cursor_coords.Y, cursor_coords.X);
354 len -= n;
355 string += n;
360 static void
361 w32con_delete_glyphs (struct frame *f, int n)
363 /* delete chars means scroll chars from cursor_coords.X + n to
364 cursor_coords.X, anything beyond the edge of the screen should
365 come out empty... */
367 scroll_line (f, n, LEFT);
370 static unsigned int sound_type = 0xFFFFFFFF;
371 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
373 void
374 w32_sys_ring_bell (struct frame *f)
376 if (sound_type == 0xFFFFFFFF)
378 Beep (666, 100);
380 else if (sound_type == MB_EMACS_SILENT)
382 /* Do nothing. */
384 else
385 MessageBeep (sound_type);
388 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
389 doc: /* Set the sound generated when the bell is rung.
390 SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
391 to use the corresponding system sound for the bell. The 'silent sound
392 prevents Emacs from making any sound at all.
393 SOUND is nil to use the normal beep. */)
394 (sound)
395 Lisp_Object sound;
397 CHECK_SYMBOL (sound);
399 if (NILP (sound))
400 sound_type = 0xFFFFFFFF;
401 else if (EQ (sound, intern ("asterisk")))
402 sound_type = MB_ICONASTERISK;
403 else if (EQ (sound, intern ("exclamation")))
404 sound_type = MB_ICONEXCLAMATION;
405 else if (EQ (sound, intern ("hand")))
406 sound_type = MB_ICONHAND;
407 else if (EQ (sound, intern ("question")))
408 sound_type = MB_ICONQUESTION;
409 else if (EQ (sound, intern ("ok")))
410 sound_type = MB_OK;
411 else if (EQ (sound, intern ("silent")))
412 sound_type = MB_EMACS_SILENT;
413 else
414 sound_type = 0xFFFFFFFF;
416 return sound;
419 static void
420 w32con_reset_terminal_modes (struct terminal *t)
422 COORD dest;
423 CONSOLE_SCREEN_BUFFER_INFO info;
424 int n;
425 DWORD r;
427 /* Clear the complete screen buffer. This is required because Emacs
428 sets the cursor position to the top of the buffer, but there might
429 be other output below the bottom of the Emacs frame if the screen buffer
430 is larger than the window size. */
431 GetConsoleScreenBufferInfo (cur_screen, &info);
432 dest.X = 0;
433 dest.Y = 0;
434 n = info.dwSize.X * info.dwSize.Y;
436 FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
437 FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
438 /* Now that the screen is clear, put the cursor at the top. */
439 SetConsoleCursorPosition (cur_screen, dest);
441 #ifdef USE_SEPARATE_SCREEN
442 SetConsoleActiveScreenBuffer (prev_screen);
443 #else
444 SetConsoleCursorInfo (prev_screen, &prev_console_cursor);
445 #endif
447 SetConsoleMode (keyboard_handle, prev_console_mode);
450 static void
451 w32con_set_terminal_modes (struct terminal *t)
453 CONSOLE_CURSOR_INFO cci;
455 /* make cursor big and visible (100 on Win95 makes it disappear) */
456 cci.dwSize = 99;
457 cci.bVisible = TRUE;
458 (void) SetConsoleCursorInfo (cur_screen, &cci);
460 SetConsoleActiveScreenBuffer (cur_screen);
462 SetConsoleMode (keyboard_handle, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
464 /* Initialize input mode: interrupt_input off, no flow control, allow
465 8 bit character input, standard quit char. */
466 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
469 /* hmmm... perhaps these let us bracket screen changes so that we can flush
470 clumps rather than one-character-at-a-time...
472 we'll start with not moving the cursor while an update is in progress. */
473 static void
474 w32con_update_begin (struct frame * f)
478 static void
479 w32con_update_end (struct frame * f)
481 SetConsoleCursorPosition (cur_screen, cursor_coords);
484 static void
485 w32con_set_terminal_window (struct frame *f, int size)
489 /***********************************************************************
490 Faces
491 ***********************************************************************/
494 /* Turn appearances of face FACE_ID on tty frame F on. */
496 static WORD
497 w32_face_attributes (f, face_id)
498 struct frame *f;
499 int face_id;
501 WORD char_attr;
502 struct face *face = FACE_FROM_ID (f, face_id);
504 xassert (face != NULL);
506 char_attr = char_attr_normal;
508 /* Reverse the default color if requested. If background and
509 foreground are specified, then they have been reversed already. */
510 if (face->tty_reverse_p)
511 char_attr = (char_attr & 0xff00) + ((char_attr & 0x000f) << 4)
512 + ((char_attr & 0x00f0) >> 4);
514 /* Before the terminal is properly initialized, all colors map to 0.
515 Don't try to resolve them. */
516 if (NILP (Vtty_defined_color_alist))
517 return char_attr;
519 /* Colors should be in the range 0...15 unless they are one of
520 FACE_TTY_DEFAULT_COLOR, FACE_TTY_DEFAULT_FG_COLOR or
521 FACE_TTY_DEFAULT_BG_COLOR. Other out of range colors are
522 invalid, so it is better to use the default color if they ever
523 get through to here. */
524 if (face->foreground >= 0 && face->foreground < 16)
525 char_attr = (char_attr & 0xfff0) + face->foreground;
527 if (face->background >= 0 && face->background < 16)
528 char_attr = (char_attr & 0xff0f) + (face->background << 4);
530 return char_attr;
535 /* Given a color index, return its standard name. */
536 Lisp_Object
537 vga_stdcolor_name (int idx)
539 /* Standard VGA colors, in the order of their standard numbering
540 in the default VGA palette. */
541 static char *vga_colors[16] = {
542 "black", "blue", "green", "cyan", "red", "magenta", "brown",
543 "lightgray", "darkgray", "lightblue", "lightgreen", "lightcyan",
544 "lightred", "lightmagenta", "yellow", "white"
547 extern Lisp_Object Qunspecified;
549 if (idx >= 0 && idx < sizeof (vga_colors) / sizeof (vga_colors[0]))
550 return build_string (vga_colors[idx]);
551 else
552 return Qunspecified; /* meaning the default */
555 typedef int (*term_hook) ();
557 void
558 initialize_w32_display (struct terminal *term)
560 CONSOLE_SCREEN_BUFFER_INFO info;
562 term->rif = 0; /* No window based redisplay on the console. */
563 term->cursor_to_hook = w32con_move_cursor;
564 term->raw_cursor_to_hook = w32con_move_cursor;
565 term->clear_to_end_hook = w32con_clear_to_end;
566 term->clear_frame_hook = w32con_clear_frame;
567 term->clear_end_of_line_hook = w32con_clear_end_of_line;
568 term->ins_del_lines_hook = w32con_ins_del_lines;
569 term->insert_glyphs_hook = w32con_insert_glyphs;
570 term->write_glyphs_hook = w32con_write_glyphs;
571 term->delete_glyphs_hook = w32con_delete_glyphs;
572 term->ring_bell_hook = w32_sys_ring_bell;
573 term->reset_terminal_modes_hook = w32con_reset_terminal_modes;
574 term->set_terminal_modes_hook = w32con_set_terminal_modes;
575 term->set_terminal_window_hook = w32con_set_terminal_window;
576 term->update_begin_hook = w32con_update_begin;
577 term->update_end_hook = w32con_update_end;
579 term->read_socket_hook = w32_console_read_socket;
580 term->mouse_position_hook = w32_console_mouse_position;
582 /* The following are not used on the console. */
583 term->frame_rehighlight_hook = 0;
584 term->frame_raise_lower_hook = 0;
585 term->set_vertical_scroll_bar_hook = 0;
586 term->condemn_scroll_bars_hook = 0;
587 term->redeem_scroll_bar_hook = 0;
588 term->judge_scroll_bars_hook = 0;
589 term->frame_up_to_date_hook = 0;
591 /* Initialize interrupt_handle. */
592 init_crit ();
594 /* Remember original console settings. */
595 keyboard_handle = GetStdHandle (STD_INPUT_HANDLE);
596 GetConsoleMode (keyboard_handle, &prev_console_mode);
598 prev_screen = GetStdHandle (STD_OUTPUT_HANDLE);
600 #ifdef USE_SEPARATE_SCREEN
601 cur_screen = CreateConsoleScreenBuffer (GENERIC_READ | GENERIC_WRITE,
602 0, NULL,
603 CONSOLE_TEXTMODE_BUFFER,
604 NULL);
606 if (cur_screen == INVALID_HANDLE_VALUE)
608 printf ("CreateConsoleScreenBuffer failed in ResetTerm\n");
609 printf ("LastError = 0x%lx\n", GetLastError ());
610 fflush (stdout);
611 exit (0);
613 #else
614 cur_screen = prev_screen;
615 GetConsoleCursorInfo (prev_screen, &prev_console_cursor);
616 #endif
618 /* Respect setting of LINES and COLUMNS environment variables. */
620 char * lines = getenv("LINES");
621 char * columns = getenv("COLUMNS");
623 if (lines != NULL && columns != NULL)
625 SMALL_RECT new_win_dims;
626 COORD new_size;
628 new_size.X = atoi (columns);
629 new_size.Y = atoi (lines);
631 GetConsoleScreenBufferInfo (cur_screen, &info);
633 /* Shrink the window first, so the buffer dimensions can be
634 reduced if necessary. */
635 new_win_dims.Top = 0;
636 new_win_dims.Left = 0;
637 new_win_dims.Bottom = min (new_size.Y, info.dwSize.Y) - 1;
638 new_win_dims.Right = min (new_size.X, info.dwSize.X) - 1;
639 SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
641 SetConsoleScreenBufferSize (cur_screen, new_size);
643 /* Set the window size to match the buffer dimension. */
644 new_win_dims.Top = 0;
645 new_win_dims.Left = 0;
646 new_win_dims.Bottom = new_size.Y - 1;
647 new_win_dims.Right = new_size.X - 1;
648 SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
652 GetConsoleScreenBufferInfo (cur_screen, &info);
654 char_attr_normal = info.wAttributes;
656 /* Determine if the info returned by GetConsoleScreenBufferInfo
657 is realistic. Old MS Telnet servers used to only fill out
658 the dwSize portion, even modern one fill the whole struct with
659 garbage when using non-MS telnet clients. */
660 if ((w32_use_full_screen_buffer
661 && (info.dwSize.Y < 20 || info.dwSize.Y > 100
662 || info.dwSize.X < 40 || info.dwSize.X > 200))
663 || (!w32_use_full_screen_buffer
664 && (info.srWindow.Bottom - info.srWindow.Top < 20
665 || info.srWindow.Bottom - info.srWindow.Top > 100
666 || info.srWindow.Right - info.srWindow.Left < 40
667 || info.srWindow.Right - info.srWindow.Left > 100)))
669 FRAME_LINES (SELECTED_FRAME ()) = 25;
670 SET_FRAME_COLS (SELECTED_FRAME (), 80);
673 else if (w32_use_full_screen_buffer)
675 FRAME_LINES (SELECTED_FRAME ()) = info.dwSize.Y; /* lines per page */
676 SET_FRAME_COLS (SELECTED_FRAME (), info.dwSize.X); /* characters per line */
678 else
680 /* Lines per page. Use buffer coords instead of buffer size. */
681 FRAME_LINES (SELECTED_FRAME ()) = 1 + info.srWindow.Bottom -
682 info.srWindow.Top;
683 /* Characters per line. Use buffer coords instead of buffer size. */
684 SET_FRAME_COLS (SELECTED_FRAME (), 1 + info.srWindow.Right -
685 info.srWindow.Left);
688 /* Setup w32_display_info structure for this frame. */
690 w32_initialize_display_info (build_string ("Console"));
695 DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
696 doc: /* Set screen colors. */)
697 (foreground, background)
698 Lisp_Object foreground;
699 Lisp_Object background;
701 char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
703 Frecenter (Qnil);
704 return Qt;
707 DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
708 doc: /* Set cursor size. */)
709 (size)
710 Lisp_Object size;
712 CONSOLE_CURSOR_INFO cci;
713 cci.dwSize = XFASTINT (size);
714 cci.bVisible = TRUE;
715 (void) SetConsoleCursorInfo (cur_screen, &cci);
717 return Qt;
720 void
721 syms_of_ntterm ()
723 DEFVAR_BOOL ("w32-use-full-screen-buffer",
724 &w32_use_full_screen_buffer,
725 doc: /* Non-nil means make terminal frames use the full screen buffer dimensions.
726 This is desirable when running Emacs over telnet.
727 A value of nil means use the current console window dimensions; this
728 may be preferrable when working directly at the console with a large
729 scroll-back buffer. */);
730 w32_use_full_screen_buffer = 0;
732 defsubr (&Sset_screen_color);
733 defsubr (&Sset_cursor_size);
734 defsubr (&Sset_message_beep);
737 /* arch-tag: a390a07f-f661-42bc-aeb4-e6d8bf860337
738 (do not change this comment) */