*** empty log message ***
[emacs.git] / src / msdos.c
bloba1113cc4d4cccaa3bcbaa5d3cce65de84b9924f5
1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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 2, or (at your option)
9 any later version.
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.
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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Morten Welinder */
22 /* New display, keyboard, and mouse control by Kim F. Storm */
24 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
26 #include <config.h>
28 #ifdef MSDOS
29 #include "lisp.h"
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <time.h>
33 #include <sys/param.h>
34 #include <sys/time.h>
35 #include <dos.h>
36 #include <errno.h>
37 #include <string.h> /* for bzero and string functions */
38 #include <sys/stat.h> /* for _fixpath */
39 #include <unistd.h> /* for chdir, dup, dup2, etc. */
40 #if __DJGPP__ >= 2
41 #include <fcntl.h>
42 #include <io.h> /* for setmode */
43 #include <dpmi.h> /* for __dpmi_xxx stuff */
44 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
45 #include <libc/dosio.h> /* for _USE_LFN */
46 #include <conio.h> /* for cputs */
47 #endif
49 #include "msdos.h"
50 #include "systime.h"
51 #include "termhooks.h"
52 #include "termchar.h"
53 #include "dispextern.h"
54 #include "dosfns.h"
55 #include "termopts.h"
56 #include "charset.h"
57 #include "coding.h"
58 #include "disptab.h"
59 #include "frame.h"
60 #include "window.h"
61 #include "buffer.h"
62 #include "commands.h"
63 #include "blockinput.h"
64 #include "keyboard.h"
65 #include <go32.h>
66 #include <pc.h>
67 #include <ctype.h>
68 /* #include <process.h> */
69 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
70 #define P_WAIT 1
72 #ifndef _USE_LFN
73 #define _USE_LFN 0
74 #endif
76 #ifndef _dos_ds
77 #define _dos_ds _go32_info_block.selector_for_linear_memory
78 #endif
80 #if __DJGPP__ > 1
82 #include <signal.h>
83 #include "syssignal.h"
85 #ifndef SYSTEM_MALLOC
87 #ifdef GNU_MALLOC
89 /* If other `malloc' than ours is used, force our `sbrk' behave like
90 Unix programs expect (resize memory blocks to keep them contiguous).
91 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
92 because that's what `gmalloc' expects to get. */
93 #include <crt0.h>
95 #ifdef REL_ALLOC
96 int _crt0_startup_flags = _CRT0_FLAG_UNIX_SBRK;
97 #else /* not REL_ALLOC */
98 int _crt0_startup_flags = (_CRT0_FLAG_UNIX_SBRK | _CRT0_FLAG_FILL_SBRK_MEMORY);
99 #endif /* not REL_ALLOC */
100 #endif /* GNU_MALLOC */
102 #endif /* not SYSTEM_MALLOC */
103 #endif /* __DJGPP__ > 1 */
105 static unsigned long
106 event_timestamp ()
108 struct time t;
109 unsigned long s;
111 gettime (&t);
112 s = t.ti_min;
113 s *= 60;
114 s += t.ti_sec;
115 s *= 1000;
116 s += t.ti_hund * 10;
118 return s;
122 /* ------------------------ Mouse control ---------------------------
124 * Coordinates are in screen positions and zero based.
125 * Mouse buttons are numbered from left to right and also zero based.
128 /* This used to be in termhooks.h, but mainstream Emacs code no longer
129 uses it, and it was removed... */
130 #define NUM_MOUSE_BUTTONS (5)
132 int have_mouse; /* 0: no, 1: enabled, -1: disabled */
133 static int mouse_visible;
135 static int mouse_last_x;
136 static int mouse_last_y;
138 static int mouse_button_translate[NUM_MOUSE_BUTTONS];
139 static int mouse_button_count;
141 void
142 mouse_on ()
144 union REGS regs;
146 if (have_mouse > 0 && !mouse_visible)
148 if (termscript)
149 fprintf (termscript, "<M_ON>");
150 regs.x.ax = 0x0001;
151 int86 (0x33, &regs, &regs);
152 mouse_visible = 1;
156 void
157 mouse_off ()
159 union REGS regs;
161 if (have_mouse > 0 && mouse_visible)
163 if (termscript)
164 fprintf (termscript, "<M_OFF>");
165 regs.x.ax = 0x0002;
166 int86 (0x33, &regs, &regs);
167 mouse_visible = 0;
171 static void
172 mouse_setup_buttons (int n_buttons)
174 if (n_buttons == 3)
176 mouse_button_count = 3;
177 mouse_button_translate[0] = 0; /* Left */
178 mouse_button_translate[1] = 2; /* Middle */
179 mouse_button_translate[2] = 1; /* Right */
181 else /* two, what else? */
183 mouse_button_count = 2;
184 mouse_button_translate[0] = 0;
185 mouse_button_translate[1] = 1;
189 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons, Smsdos_set_mouse_buttons,
190 1, 1, "NSet number of mouse buttons to: ",
191 "Set the number of mouse buttons to use by Emacs.\n\
192 This is useful with mice that report the number of buttons inconsistently,\n\
193 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of\n\
194 them. This happens with wheeled mice on Windows 9X, for example.")
195 (nbuttons)
196 Lisp_Object nbuttons;
198 CHECK_NUMBER (nbuttons, 0);
199 mouse_setup_buttons (XINT (nbuttons));
200 return Qnil;
203 static void
204 mouse_get_xy (int *x, int *y)
206 union REGS regs;
208 regs.x.ax = 0x0003;
209 int86 (0x33, &regs, &regs);
210 *x = regs.x.cx / 8;
211 *y = regs.x.dx / 8;
214 void
215 mouse_moveto (x, y)
216 int x, y;
218 union REGS regs;
220 if (termscript)
221 fprintf (termscript, "<M_XY=%dx%d>", x, y);
222 regs.x.ax = 0x0004;
223 mouse_last_x = regs.x.cx = x * 8;
224 mouse_last_y = regs.x.dx = y * 8;
225 int86 (0x33, &regs, &regs);
228 static int
229 mouse_pressed (b, xp, yp)
230 int b, *xp, *yp;
232 union REGS regs;
234 if (b >= mouse_button_count)
235 return 0;
236 regs.x.ax = 0x0005;
237 regs.x.bx = mouse_button_translate[b];
238 int86 (0x33, &regs, &regs);
239 if (regs.x.bx)
240 *xp = regs.x.cx / 8, *yp = regs.x.dx / 8;
241 return (regs.x.bx != 0);
244 static int
245 mouse_released (b, xp, yp)
246 int b, *xp, *yp;
248 union REGS regs;
250 if (b >= mouse_button_count)
251 return 0;
252 regs.x.ax = 0x0006;
253 regs.x.bx = mouse_button_translate[b];
254 int86 (0x33, &regs, &regs);
255 if (regs.x.bx)
256 *xp = regs.x.cx / 8, *yp = regs.x.dx / 8;
257 return (regs.x.bx != 0);
260 static int
261 mouse_button_depressed (b, xp, yp)
262 int b, *xp, *yp;
264 union REGS regs;
266 if (b >= mouse_button_count)
267 return 0;
268 regs.x.ax = 0x0003;
269 int86 (0x33, &regs, &regs);
270 if ((regs.x.bx & (1 << mouse_button_translate[b])) != 0)
272 *xp = regs.x.cx / 8;
273 *yp = regs.x.dx / 8;
274 return 1;
276 return 0;
279 void
280 mouse_get_pos (f, insist, bar_window, part, x, y, time)
281 FRAME_PTR *f;
282 int insist;
283 Lisp_Object *bar_window, *x, *y;
284 enum scroll_bar_part *part;
285 unsigned long *time;
287 int ix, iy;
288 Lisp_Object frame, tail;
290 /* Clear the mouse-moved flag for every frame on this display. */
291 FOR_EACH_FRAME (tail, frame)
292 XFRAME (frame)->mouse_moved = 0;
294 *f = SELECTED_FRAME();
295 *bar_window = Qnil;
296 mouse_get_xy (&ix, &iy);
297 *time = event_timestamp ();
298 *x = make_number (mouse_last_x = ix);
299 *y = make_number (mouse_last_y = iy);
302 static void
303 mouse_check_moved ()
305 int x, y;
307 mouse_get_xy (&x, &y);
308 SELECTED_FRAME()->mouse_moved |= (x != mouse_last_x || y != mouse_last_y);
309 mouse_last_x = x;
310 mouse_last_y = y;
313 /* Force the mouse driver to ``forget'' about any button clicks until
314 now. */
315 static void
316 mouse_clear_clicks (void)
318 int b;
320 for (b = 0; b < mouse_button_count; b++)
322 int dummy_x, dummy_y;
324 (void) mouse_pressed (b, &dummy_x, &dummy_y);
325 (void) mouse_released (b, &dummy_x, &dummy_y);
329 void
330 mouse_init ()
332 union REGS regs;
334 if (termscript)
335 fprintf (termscript, "<M_INIT>");
337 regs.x.ax = 0x0021;
338 int86 (0x33, &regs, &regs);
340 /* Reset the mouse last press/release info. It seems that Windows
341 doesn't do that automatically when function 21h is called, which
342 causes Emacs to ``remember'' the click that switched focus to the
343 window just before Emacs was started from that window. */
344 mouse_clear_clicks ();
346 regs.x.ax = 0x0007;
347 regs.x.cx = 0;
348 regs.x.dx = 8 * (ScreenCols () - 1);
349 int86 (0x33, &regs, &regs);
351 regs.x.ax = 0x0008;
352 regs.x.cx = 0;
353 regs.x.dx = 8 * (ScreenRows () - 1);
354 int86 (0x33, &regs, &regs);
356 mouse_moveto (0, 0);
357 mouse_visible = 0;
360 /* ------------------------- Screen control ----------------------
364 static int internal_terminal = 0;
366 #ifndef HAVE_X_WINDOWS
367 extern unsigned char ScreenAttrib;
368 static int screen_face;
369 static int highlight;
371 static int screen_size_X;
372 static int screen_size_Y;
373 static int screen_size;
375 static int current_pos_X;
376 static int current_pos_Y;
377 static int new_pos_X;
378 static int new_pos_Y;
380 static void *startup_screen_buffer;
381 static int startup_screen_size_X;
382 static int startup_screen_size_Y;
383 static int startup_pos_X;
384 static int startup_pos_Y;
385 static unsigned char startup_screen_attrib;
387 static clock_t startup_time;
389 static int term_setup_done;
391 static unsigned short outside_cursor;
393 /* Similar to the_only_frame. */
394 struct x_output the_only_x_display;
396 /* Support for DOS/V (allows Japanese characters to be displayed on
397 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
399 /* Holds the address of the text-mode screen buffer. */
400 static unsigned long screen_old_address = 0;
401 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
402 static unsigned short screen_virtual_segment = 0;
403 static unsigned short screen_virtual_offset = 0;
404 /* A flag to control how to display unibyte 8-bit characters. */
405 extern int unibyte_display_via_language_environment;
407 Lisp_Object Qbar;
409 #if __DJGPP__ > 1
410 /* Update the screen from a part of relocated DOS/V screen buffer which
411 begins at OFFSET and includes COUNT characters. */
412 static void
413 dosv_refresh_virtual_screen (int offset, int count)
415 __dpmi_regs regs;
417 if (offset < 0 || count < 0) /* paranoia; invalid values crash DOS/V */
418 return;
420 regs.h.ah = 0xff; /* update relocated screen */
421 regs.x.es = screen_virtual_segment;
422 regs.x.di = screen_virtual_offset + offset;
423 regs.x.cx = count;
424 __dpmi_int (0x10, &regs);
426 #endif
428 static void
429 dos_direct_output (y, x, buf, len)
430 int y;
431 int x;
432 char *buf;
433 int len;
435 int t0 = 2 * (x + y * screen_size_X);
436 int t = t0 + (int) ScreenPrimary;
437 int l0 = len;
439 #if (__DJGPP__ < 2)
440 while (--len >= 0) {
441 dosmemput (buf++, 1, t);
442 t += 2;
444 #else
445 /* This is faster. */
446 for (_farsetsel (_dos_ds); --len >= 0; t += 2, buf++)
447 _farnspokeb (t, *buf);
449 if (screen_virtual_segment)
450 dosv_refresh_virtual_screen (t0, l0);
451 #endif
453 #endif
455 /* Flash the screen as a substitute for BEEPs. */
457 #if (__DJGPP__ < 2)
458 static void
459 do_visible_bell (xorattr)
460 unsigned char xorattr;
462 asm volatile
463 (" movb $1,%%dl
464 visible_bell_0:
465 movl _ScreenPrimary,%%eax
466 call dosmemsetup
467 movl %%eax,%%ebx
468 movl %1,%%ecx
469 movb %0,%%al
470 incl %%ebx
471 visible_bell_1:
472 xorb %%al,%%gs:(%%ebx)
473 addl $2,%%ebx
474 decl %%ecx
475 jne visible_bell_1
476 decb %%dl
477 jne visible_bell_3
478 visible_bell_2:
479 movzwl %%ax,%%eax
480 movzwl %%ax,%%eax
481 movzwl %%ax,%%eax
482 movzwl %%ax,%%eax
483 decw %%cx
484 jne visible_bell_2
485 jmp visible_bell_0
486 visible_bell_3:"
487 : /* no output */
488 : "m" (xorattr), "g" (screen_size)
489 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
492 static void
493 ScreenVisualBell (void)
495 /* This creates an xor-mask that will swap the default fore- and
496 background colors. */
497 do_visible_bell (((the_only_x_display.foreground_pixel
498 ^ the_only_x_display.background_pixel)
499 * 0x11) & 0x7f);
501 #endif
503 #ifndef HAVE_X_WINDOWS
505 static int blink_bit = -1; /* the state of the blink bit at startup */
507 /* Enable bright background colors. */
508 static void
509 bright_bg (void)
511 union REGS regs;
513 /* Remember the original state of the blink/bright-background bit.
514 It is stored at 0040:0065h in the BIOS data area. */
515 if (blink_bit == -1)
516 blink_bit = (_farpeekb (_dos_ds, 0x465) & 0x20) == 0x20;
518 regs.h.bl = 0;
519 regs.x.ax = 0x1003;
520 int86 (0x10, &regs, &regs);
523 /* Disable bright background colors (and enable blinking) if we found
524 the video system in that state at startup. */
525 static void
526 maybe_enable_blinking (void)
528 if (blink_bit == 1)
530 union REGS regs;
532 regs.h.bl = 1;
533 regs.x.ax = 0x1003;
534 int86 (0x10, &regs, &regs);
538 /* Return non-zero if the system has a VGA adapter. */
539 static int
540 vga_installed (void)
542 union REGS regs;
544 regs.x.ax = 0x1a00;
545 int86 (0x10, &regs, &regs);
546 if (regs.h.al == 0x1a && regs.h.bl > 5 && regs.h.bl < 13)
547 return 1;
548 return 0;
551 /* Set the screen dimensions so that it can show no less than
552 ROWS x COLS frame. */
554 void
555 dos_set_window_size (rows, cols)
556 int *rows, *cols;
558 char video_name[30];
559 Lisp_Object video_mode;
560 int video_mode_value;
561 int have_vga = 0;
562 union REGS regs;
563 int current_rows = ScreenRows (), current_cols = ScreenCols ();
565 if (*rows == current_rows && *cols == current_cols)
566 return;
568 mouse_off ();
569 have_vga = vga_installed ();
571 /* If the user specified a special video mode for these dimensions,
572 use that mode. */
573 sprintf (video_name, "screen-dimensions-%dx%d", *rows, *cols);
574 video_mode = XSYMBOL (Fintern_soft (build_string (video_name),
575 Qnil))-> value;
577 if (INTEGERP (video_mode)
578 && (video_mode_value = XINT (video_mode)) > 0)
580 regs.x.ax = video_mode_value;
581 int86 (0x10, &regs, &regs);
583 if (have_mouse)
585 /* Must hardware-reset the mouse, or else it won't update
586 its notion of screen dimensions for some non-standard
587 video modes. This is *painfully* slow... */
588 regs.x.ax = 0;
589 int86 (0x33, &regs, &regs);
593 /* Find one of the dimensions supported by standard EGA/VGA
594 which gives us at least the required dimensions. */
596 #if __DJGPP__ > 1
598 else
600 static struct {
601 int rows;
602 int need_vga;
603 } std_dimension[] = {
604 {25, 0},
605 {28, 1},
606 {35, 0},
607 {40, 1},
608 {43, 0},
609 {50, 1}
611 int i = 0;
613 while (i < sizeof (std_dimension) / sizeof (std_dimension[0]))
615 if (std_dimension[i].need_vga <= have_vga
616 && std_dimension[i].rows >= *rows)
618 if (std_dimension[i].rows != current_rows
619 || *cols != current_cols)
620 _set_screen_lines (std_dimension[i].rows);
621 break;
623 i++;
627 #else /* not __DJGPP__ > 1 */
629 else if (*rows <= 25)
631 if (current_rows != 25 || current_cols != 80)
633 regs.x.ax = 3;
634 int86 (0x10, &regs, &regs);
635 regs.x.ax = 0x1101;
636 regs.h.bl = 0;
637 int86 (0x10, &regs, &regs);
638 regs.x.ax = 0x1200;
639 regs.h.bl = 32;
640 int86 (0x10, &regs, &regs);
641 regs.x.ax = 3;
642 int86 (0x10, &regs, &regs);
645 else if (*rows <= 50)
646 if (have_vga && (current_rows != 50 || current_cols != 80)
647 || *rows <= 43 && (current_rows != 43 || current_cols != 80))
649 regs.x.ax = 3;
650 int86 (0x10, &regs, &regs);
651 regs.x.ax = 0x1112;
652 regs.h.bl = 0;
653 int86 (0x10, &regs, &regs);
654 regs.x.ax = 0x1200;
655 regs.h.bl = 32;
656 int86 (0x10, &regs, &regs);
657 regs.x.ax = 0x0100;
658 regs.x.cx = 7;
659 int86 (0x10, &regs, &regs);
661 #endif /* not __DJGPP__ > 1 */
663 if (have_mouse)
665 mouse_init ();
666 mouse_on ();
669 /* Tell the caller what dimensions have been REALLY set. */
670 *rows = ScreenRows ();
671 *cols = ScreenCols ();
673 #if __DJGPP__ > 1
674 /* If the dimensions changed, the mouse highlight info is invalid. */
675 if (current_rows != *rows || current_cols != *cols)
677 struct frame *f = SELECTED_FRAME();
678 struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
679 Lisp_Object window = dpyinfo->mouse_face_window;
681 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
683 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
684 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
685 dpyinfo->mouse_face_window = Qnil;
688 #endif
690 /* Enable bright background colors. */
691 bright_bg ();
693 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
694 be defensive anyway. */
695 if (screen_virtual_segment)
696 dosv_refresh_virtual_screen (0, *cols * *rows);
699 /* If we write a character in the position where the mouse is,
700 the mouse cursor may need to be refreshed. */
702 static void
703 mouse_off_maybe ()
705 int x, y;
707 if (!mouse_visible)
708 return;
710 mouse_get_xy (&x, &y);
711 if (y != new_pos_Y || x < new_pos_X)
712 return;
714 mouse_off ();
717 #define DEFAULT_CURSOR_START (-1)
718 #define DEFAULT_CURSOR_WIDTH (-1)
719 #define BOX_CURSOR_WIDTH (-32)
721 /* Set cursor to begin at scan line START_LINE in the character cell
722 and extend for WIDTH scan lines. Scan lines are counted from top
723 of the character cell, starting from zero. */
724 static void
725 msdos_set_cursor_shape (struct frame *f, int start_line, int width)
727 #if __DJGPP__ > 1
728 unsigned desired_cursor;
729 __dpmi_regs regs;
730 int max_line, top_line, bot_line;
732 /* Avoid the costly BIOS call if F isn't the currently selected
733 frame. Allow for NULL as unconditionally meaning the selected
734 frame. */
735 if (f && f != SELECTED_FRAME())
736 return;
738 /* The character cell size in scan lines is stored at 40:85 in the
739 BIOS data area. */
740 max_line = _farpeekw (_dos_ds, 0x485) - 1;
741 switch (max_line)
743 default: /* this relies on CGA cursor emulation being ON! */
744 case 7:
745 bot_line = 7;
746 break;
747 case 9:
748 bot_line = 9;
749 break;
750 case 13:
751 bot_line = 12;
752 break;
753 case 15:
754 bot_line = 14;
755 break;
758 if (width < 0)
760 if (width == BOX_CURSOR_WIDTH)
762 top_line = 0;
763 bot_line = max_line;
765 else if (start_line != DEFAULT_CURSOR_START)
767 top_line = start_line;
768 bot_line = top_line - width - 1;
770 else if (width != DEFAULT_CURSOR_WIDTH)
772 top_line = 0;
773 bot_line = -1 - width;
775 else
776 top_line = bot_line + 1;
778 else if (width == 0)
780 /* [31, 0] seems to DTRT for all screen sizes. */
781 top_line = 31;
782 bot_line = 0;
784 else /* WIDTH is positive */
786 if (start_line != DEFAULT_CURSOR_START)
787 bot_line = start_line;
788 top_line = bot_line - (width - 1);
791 /* If the current cursor shape is already what they want, we are
792 history here. */
793 desired_cursor = ((top_line & 0x1f) << 8) | (bot_line & 0x1f);
794 if (desired_cursor == _farpeekw (_dos_ds, 0x460))
795 return;
797 regs.h.ah = 1;
798 regs.x.cx = desired_cursor;
799 __dpmi_int (0x10, &regs);
800 #endif /* __DJGPP__ > 1 */
803 static void
804 IT_set_cursor_type (struct frame *f, Lisp_Object cursor_type)
806 if (EQ (cursor_type, Qbar))
808 /* Just BAR means the normal EGA/VGA cursor. */
809 msdos_set_cursor_shape (f, DEFAULT_CURSOR_START, DEFAULT_CURSOR_WIDTH);
811 else if (CONSP (cursor_type) && EQ (XCAR (cursor_type), Qbar))
813 Lisp_Object bar_parms = XCDR (cursor_type);
814 int width;
816 if (INTEGERP (bar_parms))
818 /* Feature: negative WIDTH means cursor at the top
819 of the character cell, zero means invisible cursor. */
820 width = XINT (bar_parms);
821 msdos_set_cursor_shape (f, width >= 0 ? DEFAULT_CURSOR_START : 0,
822 width);
824 else if (CONSP (bar_parms)
825 && INTEGERP (XCAR (bar_parms))
826 && INTEGERP (XCDR (bar_parms)))
828 int start_line = XINT (XCDR (bar_parms));
830 width = XINT (XCAR (bar_parms));
831 msdos_set_cursor_shape (f, start_line, width);
834 else
835 /* Treat anything unknown as "box cursor". This includes nil, so
836 that a frame which doesn't specify a cursor type gets a box,
837 which is the default in Emacs. */
838 msdos_set_cursor_shape (f, 0, BOX_CURSOR_WIDTH);
841 static void
842 IT_ring_bell (void)
844 if (visible_bell)
846 mouse_off ();
847 ScreenVisualBell ();
849 else
851 union REGS inregs, outregs;
852 inregs.h.ah = 2;
853 inregs.h.dl = 7;
854 intdos (&inregs, &outregs);
858 /* Given a face id FACE, extract the face parameters to be used for
859 display until the face changes. The face parameters (actually, its
860 color) are used to construct the video attribute byte for each
861 glyph during the construction of the buffer that is then blitted to
862 the video RAM. */
863 static void
864 IT_set_face (int face)
866 struct frame *sf = SELECTED_FRAME();
867 struct face *fp = FACE_FROM_ID (sf, face);
868 unsigned long fg, bg;
870 if (!fp)
872 fp = FACE_FROM_ID (sf, DEFAULT_FACE_ID);
873 /* The default face for the frame should always be realized and
874 cached. */
875 if (!fp)
876 abort ();
878 screen_face = face;
879 fg = fp->foreground;
880 bg = fp->background;
882 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
883 colors mean use the colors of the default face, except that if
884 highlight is on, invert the foreground and the background. Note
885 that we assume all 16 colors to be available for the background,
886 since Emacs switches on this mode (and loses the blinking
887 attribute) at startup. */
888 if (fg == FACE_TTY_DEFAULT_COLOR || fg == FACE_TTY_DEFAULT_FG_COLOR)
889 fg = FRAME_FOREGROUND_PIXEL (sf);
890 else if (fg == FACE_TTY_DEFAULT_BG_COLOR)
891 fg = FRAME_BACKGROUND_PIXEL (sf);
892 if (bg == FACE_TTY_DEFAULT_COLOR || bg == FACE_TTY_DEFAULT_BG_COLOR)
893 bg = FRAME_BACKGROUND_PIXEL (sf);
894 else if (bg == FACE_TTY_DEFAULT_FG_COLOR)
895 bg = FRAME_FOREGROUND_PIXEL (sf);
897 /* Make sure highlighted lines really stand out, come what may. */
898 if ((highlight || fp->tty_reverse_p)
899 && (fg == FRAME_FOREGROUND_PIXEL (sf)
900 && bg == FRAME_BACKGROUND_PIXEL (sf)))
902 unsigned long tem = fg;
904 fg = bg;
905 bg = tem;
907 if (termscript)
908 fprintf (termscript, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face,
909 highlight ? "H" : "", fp->foreground, fp->background, fg, bg);
910 if (fg >= 0 && fg < 16)
912 ScreenAttrib &= 0xf0;
913 ScreenAttrib |= fg;
915 if (bg >= 0 && bg < 16)
917 ScreenAttrib &= 0x0f;
918 ScreenAttrib |= ((bg & 0x0f) << 4);
922 Lisp_Object Vdos_unsupported_char_glyph;
924 static void
925 IT_write_glyphs (struct glyph *str, int str_len)
927 unsigned char *screen_buf, *screen_bp, *screen_buf_end, *bp;
928 int unsupported_face = FAST_GLYPH_FACE (Vdos_unsupported_char_glyph);
929 unsigned unsupported_char= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph);
930 int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
931 register int sl = str_len;
932 register int tlen = GLYPH_TABLE_LENGTH;
933 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
935 /* If terminal_coding does any conversion, use it, otherwise use
936 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
937 because it always returns 1 if terminal_coding.src_multibyte is 1. */
938 struct coding_system *coding =
939 (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
940 ? &terminal_coding
941 : &safe_terminal_coding);
942 struct frame *sf;
944 /* Do we need to consider conversion of unibyte characters to
945 multibyte? */
946 int convert_unibyte_characters
947 = (NILP (current_buffer->enable_multibyte_characters)
948 && unibyte_display_via_language_environment);
950 unsigned char conversion_buffer[256];
951 int conversion_buffer_size = sizeof conversion_buffer;
953 if (str_len <= 0) return;
955 screen_buf = screen_bp = alloca (str_len * 2);
956 screen_buf_end = screen_buf + str_len * 2;
957 sf = SELECTED_FRAME();
959 /* Since faces get cached and uncached behind our back, we can't
960 rely on their indices in the cache being consistent across
961 invocations. So always reset the screen face to the default
962 face of the frame, before writing glyphs, and let the glyphs
963 set the right face if it's different from the default. */
964 IT_set_face (DEFAULT_FACE_ID);
966 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
967 the tail. */
968 terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
969 while (sl)
971 int cf, chlen, enclen;
972 unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *buf;
973 unsigned ch;
975 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
976 only for the redisplay code to know how many columns does
977 this character occupy on the screen. Skip padding glyphs. */
978 if (CHAR_GLYPH_PADDING_P (*str))
980 str++;
981 sl--;
983 else
985 register GLYPH g = GLYPH_FROM_CHAR_GLYPH (*str);
986 int glyph_not_in_table = 0;
988 if (g < 0 || g >= tlen)
990 /* This glyph doesn't have an entry in Vglyph_table. */
991 ch = str->u.ch;
992 glyph_not_in_table = 1;
994 else
996 /* This glyph has an entry in Vglyph_table, so process
997 any aliases before testing for simpleness. */
998 GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
999 ch = FAST_GLYPH_CHAR (g);
1002 /* Convert the character code to multibyte, if they
1003 requested display via language environment. We only want
1004 to convert unibyte characters to multibyte in unibyte
1005 buffers! Otherwise, the 8-bit value in CH came from the
1006 display table set up to display foreign characters. */
1007 if (SINGLE_BYTE_CHAR_P (ch) && convert_unibyte_characters
1008 && (ch >= 0240
1009 || (ch >= 0200 && !NILP (Vnonascii_translation_table))))
1010 ch = unibyte_char_to_multibyte (ch);
1012 /* Invalid characters are displayed with a special glyph. */
1013 if (! CHAR_VALID_P (ch, 0))
1015 g = !NILP (Vdos_unsupported_char_glyph)
1016 ? Vdos_unsupported_char_glyph
1017 : MAKE_GLYPH (sf, '\177', GLYPH_FACE (sf, g));
1018 ch = FAST_GLYPH_CHAR (g);
1021 /* If the face of this glyph is different from the current
1022 screen face, update the screen attribute byte. */
1023 cf = FAST_GLYPH_FACE (g);
1024 if (cf != screen_face)
1025 IT_set_face (cf); /* handles invalid faces gracefully */
1027 if (glyph_not_in_table || GLYPH_SIMPLE_P (tbase, tlen, g))
1029 /* We generate the multi-byte form of CH in WORKBUF. */
1030 chlen = CHAR_STRING (ch, workbuf);
1031 buf = workbuf;
1033 else
1035 /* We have a string in Vglyph_table. */
1036 chlen = GLYPH_LENGTH (tbase, g);
1037 buf = GLYPH_STRING (tbase, g);
1040 /* If the character is not multibyte, don't bother converting it. */
1041 if (chlen == 1)
1043 *conversion_buffer = (unsigned char)ch;
1044 chlen = 0;
1045 enclen = 1;
1047 else
1049 coding->src_multibyte = 1;
1050 encode_coding (coding, buf, conversion_buffer, chlen,
1051 conversion_buffer_size);
1052 chlen -= coding->consumed;
1053 enclen = coding->produced;
1055 /* Replace glyph codes that cannot be converted by
1056 terminal_coding with Vdos_unsupported_char_glyph. */
1057 if (*conversion_buffer == '?')
1059 unsigned char *cbp = conversion_buffer;
1061 while (cbp < conversion_buffer + enclen && *cbp == '?')
1062 *cbp++ = unsupported_char;
1063 if (unsupported_face != screen_face)
1064 IT_set_face (unsupported_face);
1068 if (enclen + chlen > screen_buf_end - screen_bp)
1070 /* The allocated buffer for screen writes is too small.
1071 Flush it and loop again without incrementing STR, so
1072 that the next loop will begin with the same glyph. */
1073 int nbytes = screen_bp - screen_buf;
1075 mouse_off_maybe ();
1076 dosmemput (screen_buf, nbytes, (int)ScreenPrimary + offset);
1077 if (screen_virtual_segment)
1078 dosv_refresh_virtual_screen (offset, nbytes / 2);
1079 new_pos_X += nbytes / 2;
1080 offset += nbytes;
1082 /* Prepare to reuse the same buffer again. */
1083 screen_bp = screen_buf;
1085 else
1087 /* There's enough place in the allocated buffer to add
1088 the encoding of this glyph. */
1090 /* First, copy the encoded bytes. */
1091 for (bp = conversion_buffer; enclen--; bp++)
1093 *screen_bp++ = (unsigned char)*bp;
1094 *screen_bp++ = ScreenAttrib;
1095 if (termscript)
1096 fputc (*bp, termscript);
1099 /* Now copy the bytes not consumed by the encoding. */
1100 if (chlen > 0)
1102 buf += coding->consumed;
1103 while (chlen--)
1105 if (termscript)
1106 fputc (*buf, termscript);
1107 *screen_bp++ = (unsigned char)*buf++;
1108 *screen_bp++ = ScreenAttrib;
1112 /* Update STR and its remaining length. */
1113 str++;
1114 sl--;
1119 /* Dump whatever is left in the screen buffer. */
1120 mouse_off_maybe ();
1121 dosmemput (screen_buf, screen_bp - screen_buf, (int)ScreenPrimary + offset);
1122 if (screen_virtual_segment)
1123 dosv_refresh_virtual_screen (offset, (screen_bp - screen_buf) / 2);
1124 new_pos_X += (screen_bp - screen_buf) / 2;
1126 /* We may have to output some codes to terminate the writing. */
1127 if (CODING_REQUIRE_FLUSHING (coding))
1129 coding->mode |= CODING_MODE_LAST_BLOCK;
1130 encode_coding (coding, "", conversion_buffer, 0, conversion_buffer_size);
1131 if (coding->produced > 0)
1133 screen_buf = alloca (coding->produced * 2);
1134 for (screen_bp = screen_buf, bp = conversion_buffer;
1135 coding->produced--; bp++)
1137 *screen_bp++ = (unsigned char)*bp;
1138 *screen_bp++ = ScreenAttrib;
1139 if (termscript)
1140 fputc (*bp, termscript);
1142 offset += screen_bp - screen_buf;
1143 mouse_off_maybe ();
1144 dosmemput (screen_buf, screen_bp - screen_buf,
1145 (int)ScreenPrimary + offset);
1146 if (screen_virtual_segment)
1147 dosv_refresh_virtual_screen (offset, (screen_bp - screen_buf) / 2);
1148 new_pos_X += (screen_bp - screen_buf) / 2;
1153 /************************************************************************
1154 Mouse Highlight (and friends..)
1155 ************************************************************************/
1157 /* This is used for debugging, to turn off note_mouse_highlight. */
1158 int disable_mouse_highlight;
1160 /* If non-nil, dos_rawgetc generates an event to display that string.
1161 (The display is done in keyboard.c:read_char, by calling
1162 show_help_echo.) */
1163 static Lisp_Object help_echo;
1164 static Lisp_Object previous_help_echo; /* a helper temporary variable */
1166 /* These record the window, the object and the position where the help
1167 echo string was generated. */
1168 static Lisp_Object help_echo_window;
1169 static Lisp_Object help_echo_object;
1170 static int help_echo_pos;
1172 static int mouse_preempted = 0; /* non-zero when XMenu gobbles mouse events */
1174 /* Set the mouse pointer shape according to whether it is in the
1175 area where the mouse highlight is in effect. */
1176 static void
1177 IT_set_mouse_pointer (int mode)
1179 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1180 many possibilities to change its shape, and the available
1181 functionality pretty much sucks (e.g., almost every reasonable
1182 shape will conceal the character it is on). Since the color of
1183 the pointer changes in the highlighted area, it is not clear to
1184 me whether anything else is required, anyway. */
1187 /* Display the active region described by mouse_face_*
1188 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1189 static void
1190 show_mouse_face (struct display_info *dpyinfo, int hl)
1192 struct window *w = XWINDOW (dpyinfo->mouse_face_window);
1193 struct frame *f = XFRAME (WINDOW_FRAME (w));
1194 int i;
1195 struct face *fp;
1198 /* If window is in the process of being destroyed, don't bother
1199 doing anything. */
1200 if (w->current_matrix == NULL)
1201 goto set_cursor_shape;
1203 /* Recognize when we are called to operate on rows that don't exist
1204 anymore. This can happen when a window is split. */
1205 if (dpyinfo->mouse_face_end_row >= w->current_matrix->nrows)
1206 goto set_cursor_shape;
1208 /* There's no sense to do anything if the mouse face isn't realized. */
1209 if (hl > 0)
1211 fp = FACE_FROM_ID (SELECTED_FRAME(), dpyinfo->mouse_face_face_id);
1212 if (!fp)
1213 goto set_cursor_shape;
1216 /* Note that mouse_face_beg_row etc. are window relative. */
1217 for (i = dpyinfo->mouse_face_beg_row;
1218 i <= dpyinfo->mouse_face_end_row;
1219 i++)
1221 int start_hpos, end_hpos;
1222 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
1224 /* Don't do anything if row doesn't have valid contents. */
1225 if (!row->enabled_p)
1226 continue;
1228 /* For all but the first row, the highlight starts at column 0. */
1229 if (i == dpyinfo->mouse_face_beg_row)
1230 start_hpos = dpyinfo->mouse_face_beg_col;
1231 else
1232 start_hpos = 0;
1234 if (i == dpyinfo->mouse_face_end_row)
1235 end_hpos = dpyinfo->mouse_face_end_col;
1236 else
1237 end_hpos = row->used[TEXT_AREA];
1239 if (end_hpos <= start_hpos)
1240 continue;
1241 /* Record that some glyphs of this row are displayed in
1242 mouse-face. */
1243 row->mouse_face_p = hl > 0;
1244 if (hl > 0)
1246 int vpos = row->y + WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
1247 int kstart = start_hpos + WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
1248 int nglyphs = end_hpos - start_hpos;
1249 int offset = ScreenPrimary + 2*(vpos*screen_size_X + kstart) + 1;
1250 int start_offset = offset;
1252 if (termscript)
1253 fprintf (termscript, "\n<MH+ %d-%d:%d>",
1254 kstart, kstart + nglyphs - 1, vpos);
1256 mouse_off ();
1257 IT_set_face (dpyinfo->mouse_face_face_id);
1258 /* Since we are going to change only the _colors_ of the
1259 displayed text, there's no need to go through all the
1260 pain of generating and encoding the text from the glyphs.
1261 Instead, we simply poke the attribute byte of each
1262 affected position in video memory with the colors
1263 computed by IT_set_face! */
1264 _farsetsel (_dos_ds);
1265 while (nglyphs--)
1267 _farnspokeb (offset, ScreenAttrib);
1268 offset += 2;
1270 if (screen_virtual_segment)
1271 dosv_refresh_virtual_screen (start_offset, end_hpos - start_hpos);
1272 mouse_on ();
1274 else
1276 /* We are removing a previously-drawn mouse highlight. The
1277 safest way to do so is to redraw the glyphs anew, since
1278 all kinds of faces and display tables could have changed
1279 behind our back. */
1280 int nglyphs = end_hpos - start_hpos;
1281 int save_x = new_pos_X, save_y = new_pos_Y;
1283 if (end_hpos >= row->used[TEXT_AREA])
1284 nglyphs = row->used[TEXT_AREA] - start_hpos;
1286 /* IT_write_glyphs writes at cursor position, so we need to
1287 temporarily move cursor coordinates to the beginning of
1288 the highlight region. */
1289 new_pos_X = start_hpos + WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
1290 new_pos_Y = row->y + WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
1292 if (termscript)
1293 fprintf (termscript, "<MH- %d-%d:%d>",
1294 new_pos_X, new_pos_X + nglyphs - 1, new_pos_Y);
1295 IT_write_glyphs (row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
1296 if (termscript)
1297 fputs ("\n", termscript);
1298 new_pos_X = save_x;
1299 new_pos_Y = save_y;
1303 set_cursor_shape:
1305 /* Change the mouse pointer shape. */
1306 IT_set_mouse_pointer (hl);
1309 /* Clear out the mouse-highlighted active region.
1310 Redraw it un-highlighted first. */
1311 static void
1312 clear_mouse_face (struct display_info *dpyinfo)
1314 if (! NILP (dpyinfo->mouse_face_window))
1315 show_mouse_face (dpyinfo, 0);
1317 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
1318 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
1319 dpyinfo->mouse_face_window = Qnil;
1322 /* Find the glyph matrix position of buffer position POS in window W.
1323 *HPOS and *VPOS are set to the positions found. W's current glyphs
1324 must be up to date. If POS is above window start return (0, 0).
1325 If POS is after end of W, return end of last line in W. */
1326 static int
1327 fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
1329 int i;
1330 int lastcol;
1331 int maybe_next_line_p = 0;
1332 int line_start_position;
1333 int yb = window_text_bottom_y (w);
1334 struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0);
1335 struct glyph_row *best_row = row;
1337 while (row->y < yb)
1339 if (row->used[TEXT_AREA])
1340 line_start_position = row->glyphs[TEXT_AREA]->charpos;
1341 else
1342 line_start_position = 0;
1344 if (line_start_position > pos)
1345 break;
1346 /* If the position sought is the end of the buffer,
1347 don't include the blank lines at the bottom of the window. */
1348 else if (line_start_position == pos
1349 && pos == BUF_ZV (XBUFFER (w->buffer)))
1351 maybe_next_line_p = 1;
1352 break;
1354 else if (line_start_position > 0)
1355 best_row = row;
1357 ++row;
1360 /* Find the right column within BEST_ROW. */
1361 lastcol = 0;
1362 row = best_row;
1363 for (i = 0; i < row->used[TEXT_AREA]; i++)
1365 struct glyph *glyph = row->glyphs[TEXT_AREA] + i;
1366 int charpos;
1368 charpos = glyph->charpos;
1369 if (charpos == pos)
1371 *hpos = i;
1372 *vpos = row->y;
1373 return 1;
1375 else if (charpos > pos)
1376 break;
1377 else if (charpos > 0)
1378 lastcol = i;
1381 /* If we're looking for the end of the buffer,
1382 and we didn't find it in the line we scanned,
1383 use the start of the following line. */
1384 if (maybe_next_line_p)
1386 ++row;
1387 lastcol = 0;
1390 *vpos = row->y;
1391 *hpos = lastcol + 1;
1392 return 0;
1395 /* Take proper action when mouse has moved to the mode or top line of
1396 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1397 mode line. X is relative to the start of the text display area of
1398 W, so the width of bitmap areas and scroll bars must be subtracted
1399 to get a position relative to the start of the mode line. */
1400 static void
1401 IT_note_mode_line_highlight (struct window *w, int x, int mode_line_p)
1403 struct frame *f = XFRAME (w->frame);
1404 struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1405 struct glyph_row *row;
1407 if (mode_line_p)
1408 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
1409 else
1410 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
1412 if (row->enabled_p)
1414 extern Lisp_Object Qhelp_echo;
1415 struct glyph *glyph, *end;
1416 Lisp_Object help, map;
1418 /* Find the glyph under X. */
1419 glyph = row->glyphs[TEXT_AREA]
1420 + x - FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
1421 end = glyph + row->used[TEXT_AREA];
1422 if (glyph < end
1423 && STRINGP (glyph->object)
1424 && XSTRING (glyph->object)->intervals
1425 && glyph->charpos >= 0
1426 && glyph->charpos < XSTRING (glyph->object)->size)
1428 /* If we're on a string with `help-echo' text property,
1429 arrange for the help to be displayed. This is done by
1430 setting the global variable help_echo to the help string. */
1431 help = Fget_text_property (make_number (glyph->charpos),
1432 Qhelp_echo, glyph->object);
1433 if (!NILP (help))
1435 help_echo = help;
1436 XSETWINDOW (help_echo_window, w);
1437 help_echo_object = glyph->object;
1438 help_echo_pos = glyph->charpos;
1444 /* Take proper action when the mouse has moved to position X, Y on
1445 frame F as regards highlighting characters that have mouse-face
1446 properties. Also de-highlighting chars where the mouse was before.
1447 X and Y can be negative or out of range. */
1448 static void
1449 IT_note_mouse_highlight (struct frame *f, int x, int y)
1451 struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1452 int portion;
1453 Lisp_Object window;
1454 struct window *w;
1456 /* When a menu is active, don't highlight because this looks odd. */
1457 if (mouse_preempted)
1458 return;
1460 if (disable_mouse_highlight
1461 || !f->glyphs_initialized_p)
1462 return;
1464 dpyinfo->mouse_face_mouse_x = x;
1465 dpyinfo->mouse_face_mouse_y = y;
1466 dpyinfo->mouse_face_mouse_frame = f;
1468 if (dpyinfo->mouse_face_defer)
1469 return;
1471 if (gc_in_progress)
1473 dpyinfo->mouse_face_deferred_gc = 1;
1474 return;
1477 /* Which window is that in? */
1478 window = window_from_coordinates (f, x, y, &portion, 0);
1480 /* If we were displaying active text in another window, clear that. */
1481 if (! EQ (window, dpyinfo->mouse_face_window))
1482 clear_mouse_face (dpyinfo);
1484 /* Not on a window -> return. */
1485 if (!WINDOWP (window))
1486 return;
1488 /* Convert to window-relative coordinates. */
1489 w = XWINDOW (window);
1490 x -= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
1491 y -= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
1493 if (portion == 1 || portion == 3)
1495 /* Mouse is on the mode or top line. */
1496 IT_note_mode_line_highlight (w, x, portion == 1);
1497 return;
1499 else
1500 IT_set_mouse_pointer (0);
1502 /* Are we in a window whose display is up to date?
1503 And verify the buffer's text has not changed. */
1504 if (/* Within text portion of the window. */
1505 portion == 0
1506 && EQ (w->window_end_valid, w->buffer)
1507 && XFASTINT (w->last_modified) == BUF_MODIFF (XBUFFER (w->buffer))
1508 && (XFASTINT (w->last_overlay_modified)
1509 == BUF_OVERLAY_MODIFF (XBUFFER (w->buffer))))
1511 int pos, i, area;
1512 struct glyph_row *row;
1513 struct glyph *glyph;
1515 /* Find the glyph under X/Y. */
1516 glyph = NULL;
1517 if (y < w->current_matrix->nrows)
1519 row = MATRIX_ROW (w->current_matrix, y);
1520 if (row->enabled_p
1521 && row->displays_text_p
1522 && x < window_box_width (w, TEXT_AREA))
1524 glyph = row->glyphs[TEXT_AREA];
1525 if (x >= row->used[TEXT_AREA])
1526 glyph = NULL;
1527 else
1529 glyph += x;
1530 if (!BUFFERP (glyph->object))
1531 glyph = NULL;
1536 /* Clear mouse face if X/Y not over text. */
1537 if (glyph == NULL)
1539 clear_mouse_face (dpyinfo);
1540 return;
1543 if (!BUFFERP (glyph->object))
1544 abort ();
1545 pos = glyph->charpos;
1547 /* Check for mouse-face and help-echo. */
1549 extern Lisp_Object Qmouse_face;
1550 Lisp_Object mouse_face, overlay, position;
1551 Lisp_Object *overlay_vec;
1552 int len, noverlays;
1553 struct buffer *obuf;
1554 int obegv, ozv;
1556 /* If we get an out-of-range value, return now; avoid an error. */
1557 if (pos > BUF_Z (XBUFFER (w->buffer)))
1558 return;
1560 /* Make the window's buffer temporarily current for
1561 overlays_at and compute_char_face. */
1562 obuf = current_buffer;
1563 current_buffer = XBUFFER (w->buffer);
1564 obegv = BEGV;
1565 ozv = ZV;
1566 BEGV = BEG;
1567 ZV = Z;
1569 /* Is this char mouse-active or does it have help-echo? */
1570 XSETINT (position, pos);
1572 /* Put all the overlays we want in a vector in overlay_vec.
1573 Store the length in len. If there are more than 10, make
1574 enough space for all, and try again. */
1575 len = 10;
1576 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
1577 noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL, 0);
1578 if (noverlays > len)
1580 len = noverlays;
1581 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
1582 noverlays = overlays_at (pos,
1583 0, &overlay_vec, &len, NULL, NULL, 0);
1586 /* Sort overlays into increasing priority order. */
1587 noverlays = sort_overlays (overlay_vec, noverlays, w);
1589 /* Check mouse-face highlighting. */
1590 if (! (EQ (window, dpyinfo->mouse_face_window)
1591 && y >= dpyinfo->mouse_face_beg_row
1592 && y <= dpyinfo->mouse_face_end_row
1593 && (y > dpyinfo->mouse_face_beg_row
1594 || x >= dpyinfo->mouse_face_beg_col)
1595 && (y < dpyinfo->mouse_face_end_row
1596 || x < dpyinfo->mouse_face_end_col
1597 || dpyinfo->mouse_face_past_end)))
1599 /* Clear the display of the old active region, if any. */
1600 clear_mouse_face (dpyinfo);
1602 /* Find highest priority overlay that has a mouse-face prop. */
1603 overlay = Qnil;
1604 for (i = noverlays - 1; i >= 0; --i)
1606 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
1607 if (!NILP (mouse_face))
1609 overlay = overlay_vec[i];
1610 break;
1614 /* If no overlay applies, get a text property. */
1615 if (NILP (overlay))
1616 mouse_face = Fget_text_property (position, Qmouse_face,
1617 w->buffer);
1619 /* Handle the overlay case. */
1620 if (! NILP (overlay))
1622 /* Find the range of text around this char that
1623 should be active. */
1624 Lisp_Object before, after;
1625 int ignore;
1627 before = Foverlay_start (overlay);
1628 after = Foverlay_end (overlay);
1629 /* Record this as the current active region. */
1630 fast_find_position (w, XFASTINT (before),
1631 &dpyinfo->mouse_face_beg_col,
1632 &dpyinfo->mouse_face_beg_row);
1633 dpyinfo->mouse_face_past_end
1634 = !fast_find_position (w, XFASTINT (after),
1635 &dpyinfo->mouse_face_end_col,
1636 &dpyinfo->mouse_face_end_row);
1637 dpyinfo->mouse_face_window = window;
1638 dpyinfo->mouse_face_face_id
1639 = face_at_buffer_position (w, pos, 0, 0,
1640 &ignore, pos + 1, 1);
1642 /* Display it as active. */
1643 show_mouse_face (dpyinfo, 1);
1645 /* Handle the text property case. */
1646 else if (! NILP (mouse_face))
1648 /* Find the range of text around this char that
1649 should be active. */
1650 Lisp_Object before, after, beginning, end;
1651 int ignore;
1653 beginning = Fmarker_position (w->start);
1654 XSETINT (end, (BUF_Z (XBUFFER (w->buffer))
1655 - XFASTINT (w->window_end_pos)));
1656 before
1657 = Fprevious_single_property_change (make_number (pos + 1),
1658 Qmouse_face,
1659 w->buffer, beginning);
1660 after
1661 = Fnext_single_property_change (position, Qmouse_face,
1662 w->buffer, end);
1663 /* Record this as the current active region. */
1664 fast_find_position (w, XFASTINT (before),
1665 &dpyinfo->mouse_face_beg_col,
1666 &dpyinfo->mouse_face_beg_row);
1667 dpyinfo->mouse_face_past_end
1668 = !fast_find_position (w, XFASTINT (after),
1669 &dpyinfo->mouse_face_end_col,
1670 &dpyinfo->mouse_face_end_row);
1671 dpyinfo->mouse_face_window = window;
1672 dpyinfo->mouse_face_face_id
1673 = face_at_buffer_position (w, pos, 0, 0,
1674 &ignore, pos + 1, 1);
1676 /* Display it as active. */
1677 show_mouse_face (dpyinfo, 1);
1681 /* Look for a `help-echo' property. */
1683 Lisp_Object help;
1684 extern Lisp_Object Qhelp_echo;
1686 /* Check overlays first. */
1687 help = Qnil;
1688 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
1690 overlay = overlay_vec[i];
1691 help = Foverlay_get (overlay, Qhelp_echo);
1694 if (!NILP (help))
1696 help_echo = help;
1697 help_echo_window = window;
1698 help_echo_object = overlay;
1699 help_echo_pos = pos;
1701 /* Try text properties. */
1702 else if (NILP (help)
1703 && ((STRINGP (glyph->object)
1704 && glyph->charpos >= 0
1705 && glyph->charpos < XSTRING (glyph->object)->size)
1706 || (BUFFERP (glyph->object)
1707 && glyph->charpos >= BEGV
1708 && glyph->charpos < ZV)))
1710 help = Fget_text_property (make_number (glyph->charpos),
1711 Qhelp_echo, glyph->object);
1712 if (!NILP (help))
1714 help_echo = help;
1715 help_echo_window = window;
1716 help_echo_object = glyph->object;
1717 help_echo_pos = glyph->charpos;
1722 BEGV = obegv;
1723 ZV = ozv;
1724 current_buffer = obuf;
1729 static void
1730 IT_clear_end_of_line (int first_unused)
1732 char *spaces, *sp;
1733 int i, j;
1734 int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
1735 extern int fatal_error_in_progress;
1737 if (new_pos_X >= first_unused || fatal_error_in_progress)
1738 return;
1740 IT_set_face (0);
1741 i = (j = first_unused - new_pos_X) * 2;
1742 if (termscript)
1743 fprintf (termscript, "<CLR:EOL[%d..%d)>", new_pos_X, first_unused);
1744 spaces = sp = alloca (i);
1746 while (--j >= 0)
1748 *sp++ = ' ';
1749 *sp++ = ScreenAttrib;
1752 mouse_off_maybe ();
1753 dosmemput (spaces, i, (int)ScreenPrimary + offset);
1754 if (screen_virtual_segment)
1755 dosv_refresh_virtual_screen (offset, i / 2);
1757 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1758 Let's follow their lead, in case someone relies on this. */
1759 new_pos_X = first_unused;
1762 static void
1763 IT_clear_screen (void)
1765 if (termscript)
1766 fprintf (termscript, "<CLR:SCR>");
1767 IT_set_face (0);
1768 mouse_off ();
1769 ScreenClear ();
1770 if (screen_virtual_segment)
1771 dosv_refresh_virtual_screen (0, screen_size);
1772 new_pos_X = new_pos_Y = 0;
1775 static void
1776 IT_clear_to_end (void)
1778 if (termscript)
1779 fprintf (termscript, "<CLR:EOS>");
1781 while (new_pos_Y < screen_size_Y) {
1782 new_pos_X = 0;
1783 IT_clear_end_of_line (screen_size_X);
1784 new_pos_Y++;
1788 static void
1789 IT_cursor_to (int y, int x)
1791 if (termscript)
1792 fprintf (termscript, "\n<XY=%dx%d>", x, y);
1793 new_pos_X = x;
1794 new_pos_Y = y;
1797 static int cursor_cleared;
1799 static void
1800 IT_display_cursor (int on)
1802 if (on && cursor_cleared)
1804 ScreenSetCursor (current_pos_Y, current_pos_X);
1805 cursor_cleared = 0;
1807 else if (!on && !cursor_cleared)
1809 ScreenSetCursor (-1, -1);
1810 cursor_cleared = 1;
1814 /* Emacs calls cursor-movement functions a lot when it updates the
1815 display (probably a legacy of old terminals where you cannot
1816 update a screen line without first moving the cursor there).
1817 However, cursor movement is expensive on MSDOS (it calls a slow
1818 BIOS function and requires 2 mode switches), while actual screen
1819 updates access the video memory directly and don't depend on
1820 cursor position. To avoid slowing down the redisplay, we cheat:
1821 all functions that move the cursor only set internal variables
1822 which record the cursor position, whereas the cursor is only
1823 moved to its final position whenever screen update is complete.
1825 `IT_cmgoto' is called from the keyboard reading loop and when the
1826 frame update is complete. This means that we are ready for user
1827 input, so we update the cursor position to show where the point is,
1828 and also make the mouse pointer visible.
1830 Special treatment is required when the cursor is in the echo area,
1831 to put the cursor at the end of the text displayed there. */
1833 static void
1834 IT_cmgoto (FRAME_PTR f)
1836 /* Only set the cursor to where it should be if the display is
1837 already in sync with the window contents. */
1838 int update_cursor_pos = 1; /* MODIFF == unchanged_modified; */
1840 /* FIXME: This needs to be rewritten for the new redisplay, or
1841 removed. */
1842 #if 0
1843 static int previous_pos_X = -1;
1845 update_cursor_pos = 1; /* temporary!!! */
1847 /* If the display is in sync, forget any previous knowledge about
1848 cursor position. This is primarily for unexpected events like
1849 C-g in the minibuffer. */
1850 if (update_cursor_pos && previous_pos_X >= 0)
1851 previous_pos_X = -1;
1852 /* If we are in the echo area, put the cursor at the
1853 end of the echo area message. */
1854 if (!update_cursor_pos
1855 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top) <= new_pos_Y)
1857 int tem_X = current_pos_X, dummy;
1859 if (echo_area_glyphs)
1861 tem_X = echo_area_glyphs_length;
1862 /* Save current cursor position, to be restored after the
1863 echo area message is erased. Only remember one level
1864 of previous cursor position. */
1865 if (previous_pos_X == -1)
1866 ScreenGetCursor (&dummy, &previous_pos_X);
1868 else if (previous_pos_X >= 0)
1870 /* We wind up here after the echo area message is erased.
1871 Restore the cursor position we remembered above. */
1872 tem_X = previous_pos_X;
1873 previous_pos_X = -1;
1876 if (current_pos_X != tem_X)
1878 new_pos_X = tem_X;
1879 update_cursor_pos = 1;
1882 #endif
1884 if (update_cursor_pos
1885 && (current_pos_X != new_pos_X || current_pos_Y != new_pos_Y))
1887 ScreenSetCursor (current_pos_Y = new_pos_Y, current_pos_X = new_pos_X);
1888 if (termscript)
1889 fprintf (termscript, "\n<CURSOR:%dx%d>", current_pos_X, current_pos_Y);
1892 /* Maybe cursor is invisible, so make it visible. */
1893 IT_display_cursor (1);
1895 /* Mouse pointer should be always visible if we are waiting for
1896 keyboard input. */
1897 if (!mouse_visible)
1898 mouse_on ();
1901 static void
1902 IT_reassert_line_highlight (int new, int vpos)
1904 highlight = new;
1907 static void
1908 IT_change_line_highlight (int new_highlight, int y, int vpos, int first_unused_hpos)
1910 highlight = new_highlight;
1911 IT_cursor_to (vpos, 0);
1912 IT_clear_end_of_line (first_unused_hpos);
1915 static void
1916 IT_update_begin (struct frame *f)
1918 struct display_info *display_info = FRAME_X_DISPLAY_INFO (f);
1919 struct frame *mouse_face_frame = display_info->mouse_face_mouse_frame;
1921 highlight = 0;
1923 BLOCK_INPUT;
1925 if (f && f == mouse_face_frame)
1927 /* Don't do highlighting for mouse motion during the update. */
1928 display_info->mouse_face_defer = 1;
1930 /* If F needs to be redrawn, simply forget about any prior mouse
1931 highlighting. */
1932 if (FRAME_GARBAGED_P (f))
1933 display_info->mouse_face_window = Qnil;
1935 /* Can we tell that this update does not affect the window
1936 where the mouse highlight is? If so, no need to turn off.
1937 Likewise, don't do anything if none of the enabled rows
1938 contains glyphs highlighted in mouse face. */
1939 if (!NILP (display_info->mouse_face_window)
1940 && WINDOWP (display_info->mouse_face_window))
1942 struct window *w = XWINDOW (display_info->mouse_face_window);
1943 int i;
1945 /* If the mouse highlight is in the window that was deleted
1946 (e.g., if it was popped by completion), clear highlight
1947 unconditionally. */
1948 if (NILP (w->buffer))
1949 display_info->mouse_face_window = Qnil;
1950 else
1952 for (i = 0; i < w->desired_matrix->nrows; ++i)
1953 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i)
1954 && MATRIX_ROW (w->current_matrix, i)->mouse_face_p)
1955 break;
1958 if (NILP (w->buffer) || i < w->desired_matrix->nrows)
1959 clear_mouse_face (display_info);
1962 else if (mouse_face_frame && !FRAME_LIVE_P (mouse_face_frame))
1964 /* If the frame with mouse highlight was deleted, invalidate the
1965 highlight info. */
1966 display_info->mouse_face_beg_row = display_info->mouse_face_beg_col = -1;
1967 display_info->mouse_face_end_row = display_info->mouse_face_end_col = -1;
1968 display_info->mouse_face_window = Qnil;
1969 display_info->mouse_face_deferred_gc = 0;
1970 display_info->mouse_face_mouse_frame = NULL;
1973 UNBLOCK_INPUT;
1976 static void
1977 IT_update_end (struct frame *f)
1979 highlight = 0;
1980 FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
1983 Lisp_Object Qcursor_type;
1985 static void
1986 IT_frame_up_to_date (struct frame *f)
1988 struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1989 Lisp_Object new_cursor, frame_desired_cursor;
1990 struct window *sw;
1992 if (dpyinfo->mouse_face_deferred_gc
1993 || (f && f == dpyinfo->mouse_face_mouse_frame))
1995 BLOCK_INPUT;
1996 if (dpyinfo->mouse_face_mouse_frame)
1997 IT_note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
1998 dpyinfo->mouse_face_mouse_x,
1999 dpyinfo->mouse_face_mouse_y);
2000 dpyinfo->mouse_face_deferred_gc = 0;
2001 UNBLOCK_INPUT;
2004 /* Set the cursor type to whatever they wanted. In a minibuffer
2005 window, we want the cursor to appear only if we are reading input
2006 from this window, and we want the cursor to be taken from the
2007 frame parameters. For the selected window, we use either its
2008 buffer-local value or the value from the frame parameters if the
2009 buffer doesn't define its local value for the cursor type. */
2010 sw = XWINDOW (f->selected_window);
2011 frame_desired_cursor = Fcdr (Fassq (Qcursor_type, f->param_alist));
2012 if (cursor_in_echo_area
2013 && FRAME_HAS_MINIBUF_P (f)
2014 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window)
2015 && sw == XWINDOW (echo_area_window))
2016 new_cursor = frame_desired_cursor;
2017 else
2019 struct buffer *b = XBUFFER (sw->buffer);
2021 if (EQ (b->cursor_type, Qt))
2022 new_cursor = frame_desired_cursor;
2023 else if (NILP (b->cursor_type)) /* nil means no cursor */
2024 new_cursor = Fcons (Qbar, make_number (0));
2025 else
2026 new_cursor = b->cursor_type;
2029 IT_set_cursor_type (f, new_cursor);
2031 IT_cmgoto (f); /* position cursor when update is done */
2034 /* Copy LEN glyphs displayed on a single line whose vertical position
2035 is YPOS, beginning at horizontal position XFROM to horizontal
2036 position XTO, by moving blocks in the video memory. Used by
2037 functions that insert and delete glyphs. */
2038 static void
2039 IT_copy_glyphs (int xfrom, int xto, size_t len, int ypos)
2041 /* The offsets of source and destination relative to the
2042 conventional memorty selector. */
2043 int from = 2 * (xfrom + screen_size_X * ypos) + ScreenPrimary;
2044 int to = 2 * (xto + screen_size_X * ypos) + ScreenPrimary;
2046 if (from == to || len <= 0)
2047 return;
2049 _farsetsel (_dos_ds);
2051 /* The source and destination might overlap, so we need to move
2052 glyphs non-destructively. */
2053 if (from > to)
2055 for ( ; len; from += 2, to += 2, len--)
2056 _farnspokew (to, _farnspeekw (from));
2058 else
2060 from += (len - 1) * 2;
2061 to += (len - 1) * 2;
2062 for ( ; len; from -= 2, to -= 2, len--)
2063 _farnspokew (to, _farnspeekw (from));
2065 if (screen_virtual_segment)
2066 dosv_refresh_virtual_screen (ypos * screen_size_X * 2, screen_size_X);
2069 /* Insert and delete glyphs. */
2070 static void
2071 IT_insert_glyphs (start, len)
2072 register struct glyph *start;
2073 register int len;
2075 int shift_by_width = screen_size_X - (new_pos_X + len);
2077 /* Shift right the glyphs from the nominal cursor position to the
2078 end of this line. */
2079 IT_copy_glyphs (new_pos_X, new_pos_X + len, shift_by_width, new_pos_Y);
2081 /* Now write the glyphs to be inserted. */
2082 IT_write_glyphs (start, len);
2085 static void
2086 IT_delete_glyphs (n)
2087 register int n;
2089 abort ();
2092 /* set-window-configuration on window.c needs this. */
2093 void
2094 x_set_menu_bar_lines (f, value, oldval)
2095 struct frame *f;
2096 Lisp_Object value, oldval;
2098 set_menu_bar_lines (f, value, oldval);
2101 /* This was copied from xfns.c */
2103 Lisp_Object Qbackground_color;
2104 Lisp_Object Qforeground_color;
2105 Lisp_Object Qreverse;
2106 extern Lisp_Object Qtitle;
2108 /* IT_set_terminal_modes is called when emacs is started,
2109 resumed, and whenever the screen is redrawn! */
2111 static void
2112 IT_set_terminal_modes (void)
2114 if (termscript)
2115 fprintf (termscript, "\n<SET_TERM>");
2116 highlight = 0;
2118 screen_size_X = ScreenCols ();
2119 screen_size_Y = ScreenRows ();
2120 screen_size = screen_size_X * screen_size_Y;
2122 new_pos_X = new_pos_Y = 0;
2123 current_pos_X = current_pos_Y = -1;
2125 if (term_setup_done)
2126 return;
2127 term_setup_done = 1;
2129 startup_screen_size_X = screen_size_X;
2130 startup_screen_size_Y = screen_size_Y;
2131 startup_screen_attrib = ScreenAttrib;
2133 #if __DJGPP__ > 1
2134 /* Is DOS/V (or any other RSIS software which relocates
2135 the screen) installed? */
2137 unsigned short es_value;
2138 __dpmi_regs regs;
2140 regs.h.ah = 0xfe; /* get relocated screen address */
2141 if (ScreenPrimary == 0xb0000UL || ScreenPrimary == 0xb8000UL)
2142 regs.x.es = (ScreenPrimary >> 4) & 0xffff;
2143 else if (screen_old_address) /* already switched to Japanese mode once */
2144 regs.x.es = (screen_old_address >> 4) & 0xffff;
2145 else
2146 regs.x.es = ScreenMode () == 7 ? 0xb000 : 0xb800;
2147 regs.x.di = 0;
2148 es_value = regs.x.es;
2149 __dpmi_int (0x10, &regs);
2151 if (regs.x.es != es_value)
2153 /* screen_old_address is only set if ScreenPrimary does NOT
2154 already point to the relocated buffer address returned by
2155 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2156 ScreenPrimary to that address at startup under DOS/V. */
2157 if (regs.x.es != (ScreenPrimary >> 4) & 0xffff)
2158 screen_old_address = ScreenPrimary;
2159 screen_virtual_segment = regs.x.es;
2160 screen_virtual_offset = regs.x.di;
2161 ScreenPrimary = (screen_virtual_segment << 4) + screen_virtual_offset;
2164 #endif /* __DJGPP__ > 1 */
2166 ScreenGetCursor (&startup_pos_Y, &startup_pos_X);
2167 ScreenRetrieve (startup_screen_buffer = xmalloc (screen_size * 2));
2169 if (termscript)
2170 fprintf (termscript, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2171 screen_size_X, screen_size_Y);
2173 bright_bg ();
2176 /* IT_reset_terminal_modes is called when emacs is
2177 suspended or killed. */
2179 static void
2180 IT_reset_terminal_modes (void)
2182 int display_row_start = (int) ScreenPrimary;
2183 int saved_row_len = startup_screen_size_X * 2;
2184 int update_row_len = ScreenCols () * 2;
2185 int current_rows = ScreenRows ();
2186 int to_next_row = update_row_len;
2187 unsigned char *saved_row = startup_screen_buffer;
2188 int cursor_pos_X = ScreenCols () - 1;
2189 int cursor_pos_Y = ScreenRows () - 1;
2191 if (termscript)
2192 fprintf (termscript, "\n<RESET_TERM>");
2194 highlight = 0;
2196 if (!term_setup_done)
2197 return;
2199 mouse_off ();
2201 /* Leave the video system in the same state as we found it,
2202 as far as the blink/bright-background bit is concerned. */
2203 maybe_enable_blinking ();
2205 /* We have a situation here.
2206 We cannot just do ScreenUpdate(startup_screen_buffer) because
2207 the luser could have changed screen dimensions inside Emacs
2208 and failed (or didn't want) to restore them before killing
2209 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2210 thus will happily use memory outside what was allocated for
2211 `startup_screen_buffer'.
2212 Thus we only restore as much as the current screen dimensions
2213 can hold, and clear the rest (if the saved screen is smaller than
2214 the current) with the color attribute saved at startup. The cursor
2215 is also restored within the visible dimensions. */
2217 ScreenAttrib = startup_screen_attrib;
2219 /* Don't restore the screen if we are exiting less than 2 seconds
2220 after startup: we might be crashing, and the screen might show
2221 some vital clues to what's wrong. */
2222 if (clock () - startup_time >= 2*CLOCKS_PER_SEC)
2224 ScreenClear ();
2225 if (screen_virtual_segment)
2226 dosv_refresh_virtual_screen (0, screen_size);
2228 if (update_row_len > saved_row_len)
2229 update_row_len = saved_row_len;
2230 if (current_rows > startup_screen_size_Y)
2231 current_rows = startup_screen_size_Y;
2233 if (termscript)
2234 fprintf (termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2235 update_row_len / 2, current_rows);
2237 while (current_rows--)
2239 dosmemput (saved_row, update_row_len, display_row_start);
2240 if (screen_virtual_segment)
2241 dosv_refresh_virtual_screen (display_row_start - ScreenPrimary,
2242 update_row_len / 2);
2243 saved_row += saved_row_len;
2244 display_row_start += to_next_row;
2247 if (startup_pos_X < cursor_pos_X)
2248 cursor_pos_X = startup_pos_X;
2249 if (startup_pos_Y < cursor_pos_Y)
2250 cursor_pos_Y = startup_pos_Y;
2252 ScreenSetCursor (cursor_pos_Y, cursor_pos_X);
2253 xfree (startup_screen_buffer);
2255 term_setup_done = 0;
2258 static void
2259 IT_set_terminal_window (int foo)
2263 /* Remember the screen colors of the curent frame, to serve as the
2264 default colors for newly-created frames. */
2266 static int initial_screen_colors[2];
2268 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors,
2269 Smsdos_remember_default_colors, 1, 1, 0,
2270 "Remember the screen colors of the current frame.")
2271 (frame)
2272 Lisp_Object frame;
2274 int reverse;
2275 struct frame *f;
2277 CHECK_FRAME (frame, 0);
2278 f= XFRAME (frame);
2279 reverse = EQ (Fcdr (Fassq (intern ("reverse"), f->param_alist)), Qt);
2281 initial_screen_colors[0]
2282 = reverse ? FRAME_BACKGROUND_PIXEL (f) : FRAME_FOREGROUND_PIXEL (f);
2283 initial_screen_colors[1]
2284 = reverse ? FRAME_FOREGROUND_PIXEL (f) : FRAME_BACKGROUND_PIXEL (f);
2287 void
2288 IT_set_frame_parameters (f, alist)
2289 struct frame *f;
2290 Lisp_Object alist;
2292 Lisp_Object tail;
2293 int length = XINT (Flength (alist));
2294 int i, j;
2295 Lisp_Object *parms
2296 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2297 Lisp_Object *values
2298 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2299 /* Do we have to reverse the foreground and background colors? */
2300 int reverse = EQ (Fcdr (Fassq (Qreverse, f->param_alist)), Qt);
2301 int was_reverse = reverse;
2302 int redraw = 0, fg_set = 0, bg_set = 0;
2303 unsigned long orig_fg;
2304 unsigned long orig_bg;
2306 /* If we are creating a new frame, begin with the original screen colors
2307 used for the initial frame. */
2308 if (alist == Vdefault_frame_alist
2309 && initial_screen_colors[0] != -1 && initial_screen_colors[1] != -1)
2311 FRAME_FOREGROUND_PIXEL (f) = initial_screen_colors[0];
2312 FRAME_BACKGROUND_PIXEL (f) = initial_screen_colors[1];
2314 orig_fg = FRAME_FOREGROUND_PIXEL (f);
2315 orig_bg = FRAME_BACKGROUND_PIXEL (f);
2317 /* Extract parm names and values into those vectors. */
2318 i = 0;
2319 for (tail = alist; CONSP (tail); tail = Fcdr (tail))
2321 Lisp_Object elt;
2323 elt = Fcar (tail);
2324 parms[i] = Fcar (elt);
2325 CHECK_SYMBOL (parms[i], 1);
2326 values[i] = Fcdr (elt);
2327 i++;
2330 j = i;
2332 for (i = 0; i < j; i++)
2334 Lisp_Object prop = parms[i];
2335 Lisp_Object val = values[i];
2337 if (EQ (prop, Qreverse))
2338 reverse = EQ (val, Qt);
2341 if (termscript && reverse && !was_reverse)
2342 fprintf (termscript, "<INVERSE-VIDEO>\n");
2344 /* Now process the alist elements in reverse of specified order. */
2345 for (i--; i >= 0; i--)
2347 Lisp_Object prop = parms[i];
2348 Lisp_Object val = values[i];
2350 if (EQ (prop, Qforeground_color))
2352 unsigned long new_color = load_color (f, NULL, val, reverse
2353 ? LFACE_BACKGROUND_INDEX
2354 : LFACE_FOREGROUND_INDEX);
2355 if (new_color != FACE_TTY_DEFAULT_COLOR
2356 && new_color != FACE_TTY_DEFAULT_FG_COLOR
2357 && new_color != FACE_TTY_DEFAULT_BG_COLOR)
2359 if (reverse)
2360 /* FIXME: should the fore-/background of the default
2361 face change here as well? */
2362 FRAME_BACKGROUND_PIXEL (f) = new_color;
2363 else
2364 FRAME_FOREGROUND_PIXEL (f) = new_color;
2365 redraw = 1;
2366 fg_set = 1;
2367 if (termscript)
2368 fprintf (termscript, "<FGCOLOR %lu>\n", new_color);
2371 else if (EQ (prop, Qbackground_color))
2373 unsigned long new_color = load_color (f, NULL, val, reverse
2374 ? LFACE_FOREGROUND_INDEX
2375 : LFACE_BACKGROUND_INDEX);
2376 if (new_color != FACE_TTY_DEFAULT_COLOR
2377 && new_color != FACE_TTY_DEFAULT_FG_COLOR
2378 && new_color != FACE_TTY_DEFAULT_BG_COLOR)
2380 if (reverse)
2381 FRAME_FOREGROUND_PIXEL (f) = new_color;
2382 else
2383 FRAME_BACKGROUND_PIXEL (f) = new_color;
2384 redraw = 1;
2385 bg_set = 1;
2386 if (termscript)
2387 fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
2390 else if (EQ (prop, Qtitle))
2392 x_set_title (f, val);
2393 if (termscript)
2394 fprintf (termscript, "<TITLE: %s>\n", XSTRING (val)->data);
2396 else if (EQ (prop, Qcursor_type))
2398 IT_set_cursor_type (f, val);
2399 if (termscript)
2400 fprintf (termscript, "<CTYPE: %s>\n",
2401 EQ (val, Qbar) || CONSP (val) && EQ (XCAR (val), Qbar)
2402 ? "bar" : "box");
2404 store_frame_param (f, prop, val);
2407 /* If they specified "reverse", but not the colors, we need to swap
2408 the current frame colors. */
2409 if (reverse && !was_reverse)
2411 if (!fg_set)
2413 FRAME_BACKGROUND_PIXEL (f) = orig_fg;
2414 redraw = 1;
2416 if (!bg_set)
2418 FRAME_FOREGROUND_PIXEL (f) = orig_bg;
2419 redraw = 1;
2423 if (redraw)
2425 face_change_count++; /* forces xdisp.c to recompute basic faces */
2426 if (f == SELECTED_FRAME())
2427 redraw_frame (f);
2431 extern void init_frame_faces (FRAME_PTR);
2433 #endif /* !HAVE_X_WINDOWS */
2436 /* Do we need the internal terminal? */
2438 void
2439 internal_terminal_init ()
2441 char *term = getenv ("TERM");
2442 char *colors;
2443 struct frame *sf = SELECTED_FRAME();
2445 #ifdef HAVE_X_WINDOWS
2446 if (!inhibit_window_system)
2447 return;
2448 #endif
2450 internal_terminal
2451 = (!noninteractive) && term && !strcmp (term, "internal");
2453 if (getenv ("EMACSTEST"))
2454 termscript = fopen (getenv ("EMACSTEST"), "wt");
2456 #ifndef HAVE_X_WINDOWS
2457 if (!internal_terminal || inhibit_window_system)
2459 sf->output_method = output_termcap;
2460 return;
2463 Vwindow_system = intern ("pc");
2464 Vwindow_system_version = make_number (1);
2465 sf->output_method = output_msdos_raw;
2467 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2468 screen_old_address = 0;
2470 /* Forget the stale screen colors as well. */
2471 initial_screen_colors[0] = initial_screen_colors[1] = -1;
2473 bzero (&the_only_x_display, sizeof the_only_x_display);
2474 the_only_x_display.background_pixel = 7; /* White */
2475 the_only_x_display.foreground_pixel = 0; /* Black */
2476 bright_bg ();
2477 colors = getenv ("EMACSCOLORS");
2478 if (colors && strlen (colors) >= 2)
2480 /* The colors use 4 bits each (we enable bright background). */
2481 if (isdigit (colors[0]))
2482 colors[0] -= '0';
2483 else if (isxdigit (colors[0]))
2484 colors[0] -= (isupper (colors[0]) ? 'A' : 'a') - 10;
2485 if (colors[0] >= 0 && colors[0] < 16)
2486 the_only_x_display.foreground_pixel = colors[0];
2487 if (isdigit (colors[1]))
2488 colors[1] -= '0';
2489 else if (isxdigit (colors[1]))
2490 colors[1] -= (isupper (colors[1]) ? 'A' : 'a') - 10;
2491 if (colors[1] >= 0 && colors[1] < 16)
2492 the_only_x_display.background_pixel = colors[1];
2494 the_only_x_display.line_height = 1;
2495 the_only_x_display.font = (XFontStruct *)1; /* must *not* be zero */
2496 the_only_x_display.display_info.mouse_face_mouse_frame = NULL;
2497 the_only_x_display.display_info.mouse_face_deferred_gc = 0;
2498 the_only_x_display.display_info.mouse_face_beg_row =
2499 the_only_x_display.display_info.mouse_face_beg_col = -1;
2500 the_only_x_display.display_info.mouse_face_end_row =
2501 the_only_x_display.display_info.mouse_face_end_col = -1;
2502 the_only_x_display.display_info.mouse_face_face_id = DEFAULT_FACE_ID;
2503 the_only_x_display.display_info.mouse_face_window = Qnil;
2504 the_only_x_display.display_info.mouse_face_mouse_x =
2505 the_only_x_display.display_info.mouse_face_mouse_y = 0;
2506 the_only_x_display.display_info.mouse_face_defer = 0;
2508 init_frame_faces (sf);
2510 ring_bell_hook = IT_ring_bell;
2511 insert_glyphs_hook = IT_insert_glyphs;
2512 delete_glyphs_hook = IT_delete_glyphs;
2513 write_glyphs_hook = IT_write_glyphs;
2514 cursor_to_hook = raw_cursor_to_hook = IT_cursor_to;
2515 clear_to_end_hook = IT_clear_to_end;
2516 clear_end_of_line_hook = IT_clear_end_of_line;
2517 clear_frame_hook = IT_clear_screen;
2518 change_line_highlight_hook = IT_change_line_highlight;
2519 update_begin_hook = IT_update_begin;
2520 update_end_hook = IT_update_end;
2521 reassert_line_highlight_hook = IT_reassert_line_highlight;
2522 frame_up_to_date_hook = IT_frame_up_to_date;
2524 /* These hooks are called by term.c without being checked. */
2525 set_terminal_modes_hook = IT_set_terminal_modes;
2526 reset_terminal_modes_hook = IT_reset_terminal_modes;
2527 set_terminal_window_hook = IT_set_terminal_window;
2528 char_ins_del_ok = 0;
2529 #endif
2532 dos_get_saved_screen (screen, rows, cols)
2533 char **screen;
2534 int *rows;
2535 int *cols;
2537 #ifndef HAVE_X_WINDOWS
2538 *screen = startup_screen_buffer;
2539 *cols = startup_screen_size_X;
2540 *rows = startup_screen_size_Y;
2541 return *screen != (char *)0;
2542 #else
2543 return 0;
2544 #endif
2547 #ifndef HAVE_X_WINDOWS
2549 /* We are not X, but we can emulate it well enough for our needs... */
2550 void
2551 check_x (void)
2553 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2554 error ("Not running under a window system");
2557 #endif
2560 /* ----------------------- Keyboard control ----------------------
2562 * Keymaps reflect the following keyboard layout:
2564 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2565 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2566 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2567 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2568 * SPACE
2571 #define Ignore 0x0000
2572 #define Normal 0x0000 /* normal key - alt changes scan-code */
2573 #define FctKey 0x1000 /* func key if c == 0, else c */
2574 #define Special 0x2000 /* func key even if c != 0 */
2575 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2576 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2577 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2578 #define Grey 0x6000 /* Grey keypad key */
2580 #define Alt 0x0100 /* alt scan-code */
2581 #define Ctrl 0x0200 /* ctrl scan-code */
2582 #define Shift 0x0400 /* shift scan-code */
2584 static int extended_kbd; /* 101 (102) keyboard present. */
2586 struct kbd_translate {
2587 unsigned char sc;
2588 unsigned char ch;
2589 unsigned short code;
2592 struct dos_keyboard_map
2594 char *unshifted;
2595 char *shifted;
2596 char *alt_gr;
2597 struct kbd_translate *translate_table;
2601 static struct dos_keyboard_map us_keyboard = {
2602 /* 0 1 2 3 4 5 */
2603 /* 01234567890123456789012345678901234567890 12345678901234 */
2604 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2605 /* 0123456789012345678901234567890123456789 012345678901234 */
2606 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2607 0, /* no Alt-Gr key */
2608 0 /* no translate table */
2611 static struct dos_keyboard_map fr_keyboard = {
2612 /* 0 1 2 3 4 5 */
2613 /* 012 3456789012345678901234567890123456789012345678901234 */
2614 "ý&‚\",(-Š_€…)= azertyuiop^$ qsdfghjklm—* wxcvbnm;:! ",
2615 /* 0123456789012345678901234567890123456789012345678901234 */
2616 " 1234567890ø+ AZERTYUIOPùœ QSDFGHJKLM%æ WXCVBN?./õ ",
2617 /* 01234567 89012345678901234567890123456789012345678901234 */
2618 " ~#{[|`\\^@]} Ï ",
2619 0 /* no translate table */
2623 * Italian keyboard support, country code 39.
2624 * '<' 56:3c*0000
2625 * '>' 56:3e*0000
2626 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2627 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2630 static struct kbd_translate it_kbd_translate_table[] = {
2631 { 0x56, 0x3c, Normal | 13 },
2632 { 0x56, 0x3e, Normal | 27 },
2633 { 0, 0, 0 }
2635 static struct dos_keyboard_map it_keyboard = {
2636 /* 0 1 2 3 4 5 */
2637 /* 0 123456789012345678901234567890123456789012345678901234 */
2638 "\\1234567890'�< qwertyuiopŠ+> asdfghjkl•…— zxcvbnm,.- ",
2639 /* 01 23456789012345678901234567890123456789012345678901234 */
2640 "|!\"œ$%&/()=?^> QWERTYUIOP‚* ASDFGHJKL‡øõ ZXCVBNM;:_ ",
2641 /* 0123456789012345678901234567890123456789012345678901234 */
2642 " {}~` [] @# ",
2643 it_kbd_translate_table
2646 static struct dos_keyboard_map dk_keyboard = {
2647 /* 0 1 2 3 4 5 */
2648 /* 0123456789012345678901234567890123456789012345678901234 */
2649 "«1234567890+| qwertyuiop†~ asdfghjkl‘›' zxcvbnm,.- ",
2650 /* 01 23456789012345678901234567890123456789012345678901234 */
2651 "õ!\"#$%&/()=?` QWERTYUIOP�^ ASDFGHJKL’�* ZXCVBNM;:_ ",
2652 /* 0123456789012345678901234567890123456789012345678901234 */
2653 " @œ$ {[]} | ",
2654 0 /* no translate table */
2657 static struct kbd_translate jp_kbd_translate_table[] = {
2658 { 0x73, 0x5c, Normal | 0 },
2659 { 0x73, 0x5f, Normal | 0 },
2660 { 0x73, 0x1c, Map | 0 },
2661 { 0x7d, 0x5c, Normal | 13 },
2662 { 0x7d, 0x7c, Normal | 13 },
2663 { 0x7d, 0x1c, Map | 13 },
2664 { 0, 0, 0 }
2666 static struct dos_keyboard_map jp_keyboard = {
2667 /* 0 1 2 3 4 5 */
2668 /* 0123456789012 345678901234567890123456789012345678901234 */
2669 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2670 /* 01 23456789012345678901234567890123456789012345678901234 */
2671 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2672 0, /* no Alt-Gr key */
2673 jp_kbd_translate_table
2676 static struct keyboard_layout_list
2678 int country_code;
2679 struct dos_keyboard_map *keyboard_map;
2680 } keyboard_layout_list[] =
2682 1, &us_keyboard,
2683 33, &fr_keyboard,
2684 39, &it_keyboard,
2685 45, &dk_keyboard,
2686 81, &jp_keyboard
2689 static struct dos_keyboard_map *keyboard;
2690 static int keyboard_map_all;
2691 static int international_keyboard;
2694 dos_set_keyboard (code, always)
2695 int code;
2696 int always;
2698 int i;
2699 _go32_dpmi_registers regs;
2701 /* See if Keyb.Com is installed (for international keyboard support).
2702 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2703 of Windows 9X! So don't do that! */
2704 regs.x.ax = 0xad80;
2705 regs.x.ss = regs.x.sp = regs.x.flags = 0;
2706 _go32_dpmi_simulate_int (0x2f, &regs);
2707 if (regs.h.al == 0xff)
2708 international_keyboard = 1;
2710 /* Initialize to US settings, for countries that don't have their own. */
2711 keyboard = keyboard_layout_list[0].keyboard_map;
2712 keyboard_map_all = always;
2713 dos_keyboard_layout = 1;
2715 for (i = 0; i < (sizeof (keyboard_layout_list)/sizeof (struct keyboard_layout_list)); i++)
2716 if (code == keyboard_layout_list[i].country_code)
2718 keyboard = keyboard_layout_list[i].keyboard_map;
2719 keyboard_map_all = always;
2720 dos_keyboard_layout = code;
2721 return 1;
2723 return 0;
2726 static struct
2728 unsigned char char_code; /* normal code */
2729 unsigned char meta_code; /* M- code */
2730 unsigned char keypad_code; /* keypad code */
2731 unsigned char editkey_code; /* edit key */
2732 } keypad_translate_map[] = {
2733 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2734 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2735 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2736 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2737 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2738 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2739 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2740 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2741 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2742 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2743 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2746 static struct
2748 unsigned char char_code; /* normal code */
2749 unsigned char keypad_code; /* keypad code */
2750 } grey_key_translate_map[] = {
2751 '/', 0xaf, /* kp-decimal */
2752 '*', 0xaa, /* kp-multiply */
2753 '-', 0xad, /* kp-subtract */
2754 '+', 0xab, /* kp-add */
2755 '\r', 0x8d /* kp-enter */
2758 static unsigned short
2759 ibmpc_translate_map[] =
2761 /* --------------- 00 to 0f --------------- */
2762 Normal | 0xff, /* Ctrl Break + Alt-NNN */
2763 Alt | ModFct | 0x1b, /* Escape */
2764 Normal | 1, /* '1' */
2765 Normal | 2, /* '2' */
2766 Normal | 3, /* '3' */
2767 Normal | 4, /* '4' */
2768 Normal | 5, /* '5' */
2769 Normal | 6, /* '6' */
2770 Normal | 7, /* '7' */
2771 Normal | 8, /* '8' */
2772 Normal | 9, /* '9' */
2773 Normal | 10, /* '0' */
2774 Normal | 11, /* '-' */
2775 Normal | 12, /* '=' */
2776 Special | 0x08, /* Backspace */
2777 ModFct | 0x74, /* Tab/Backtab */
2779 /* --------------- 10 to 1f --------------- */
2780 Map | 15, /* 'q' */
2781 Map | 16, /* 'w' */
2782 Map | 17, /* 'e' */
2783 Map | 18, /* 'r' */
2784 Map | 19, /* 't' */
2785 Map | 20, /* 'y' */
2786 Map | 21, /* 'u' */
2787 Map | 22, /* 'i' */
2788 Map | 23, /* 'o' */
2789 Map | 24, /* 'p' */
2790 Map | 25, /* '[' */
2791 Map | 26, /* ']' */
2792 ModFct | 0x0d, /* Return */
2793 Ignore, /* Ctrl */
2794 Map | 30, /* 'a' */
2795 Map | 31, /* 's' */
2797 /* --------------- 20 to 2f --------------- */
2798 Map | 32, /* 'd' */
2799 Map | 33, /* 'f' */
2800 Map | 34, /* 'g' */
2801 Map | 35, /* 'h' */
2802 Map | 36, /* 'j' */
2803 Map | 37, /* 'k' */
2804 Map | 38, /* 'l' */
2805 Map | 39, /* ';' */
2806 Map | 40, /* '\'' */
2807 Map | 0, /* '`' */
2808 Ignore, /* Left shift */
2809 Map | 41, /* '\\' */
2810 Map | 45, /* 'z' */
2811 Map | 46, /* 'x' */
2812 Map | 47, /* 'c' */
2813 Map | 48, /* 'v' */
2815 /* --------------- 30 to 3f --------------- */
2816 Map | 49, /* 'b' */
2817 Map | 50, /* 'n' */
2818 Map | 51, /* 'm' */
2819 Map | 52, /* ',' */
2820 Map | 53, /* '.' */
2821 Map | 54, /* '/' */
2822 Ignore, /* Right shift */
2823 Grey | 1, /* Grey * */
2824 Ignore, /* Alt */
2825 Normal | 55, /* ' ' */
2826 Ignore, /* Caps Lock */
2827 FctKey | 0xbe, /* F1 */
2828 FctKey | 0xbf, /* F2 */
2829 FctKey | 0xc0, /* F3 */
2830 FctKey | 0xc1, /* F4 */
2831 FctKey | 0xc2, /* F5 */
2833 /* --------------- 40 to 4f --------------- */
2834 FctKey | 0xc3, /* F6 */
2835 FctKey | 0xc4, /* F7 */
2836 FctKey | 0xc5, /* F8 */
2837 FctKey | 0xc6, /* F9 */
2838 FctKey | 0xc7, /* F10 */
2839 Ignore, /* Num Lock */
2840 Ignore, /* Scroll Lock */
2841 KeyPad | 7, /* Home */
2842 KeyPad | 8, /* Up */
2843 KeyPad | 9, /* Page Up */
2844 Grey | 2, /* Grey - */
2845 KeyPad | 4, /* Left */
2846 KeyPad | 5, /* Keypad 5 */
2847 KeyPad | 6, /* Right */
2848 Grey | 3, /* Grey + */
2849 KeyPad | 1, /* End */
2851 /* --------------- 50 to 5f --------------- */
2852 KeyPad | 2, /* Down */
2853 KeyPad | 3, /* Page Down */
2854 KeyPad | 0, /* Insert */
2855 KeyPad | 10, /* Delete */
2856 Shift | FctKey | 0xbe, /* (Shift) F1 */
2857 Shift | FctKey | 0xbf, /* (Shift) F2 */
2858 Shift | FctKey | 0xc0, /* (Shift) F3 */
2859 Shift | FctKey | 0xc1, /* (Shift) F4 */
2860 Shift | FctKey | 0xc2, /* (Shift) F5 */
2861 Shift | FctKey | 0xc3, /* (Shift) F6 */
2862 Shift | FctKey | 0xc4, /* (Shift) F7 */
2863 Shift | FctKey | 0xc5, /* (Shift) F8 */
2864 Shift | FctKey | 0xc6, /* (Shift) F9 */
2865 Shift | FctKey | 0xc7, /* (Shift) F10 */
2866 Ctrl | FctKey | 0xbe, /* (Ctrl) F1 */
2867 Ctrl | FctKey | 0xbf, /* (Ctrl) F2 */
2869 /* --------------- 60 to 6f --------------- */
2870 Ctrl | FctKey | 0xc0, /* (Ctrl) F3 */
2871 Ctrl | FctKey | 0xc1, /* (Ctrl) F4 */
2872 Ctrl | FctKey | 0xc2, /* (Ctrl) F5 */
2873 Ctrl | FctKey | 0xc3, /* (Ctrl) F6 */
2874 Ctrl | FctKey | 0xc4, /* (Ctrl) F7 */
2875 Ctrl | FctKey | 0xc5, /* (Ctrl) F8 */
2876 Ctrl | FctKey | 0xc6, /* (Ctrl) F9 */
2877 Ctrl | FctKey | 0xc7, /* (Ctrl) F10 */
2878 Alt | FctKey | 0xbe, /* (Alt) F1 */
2879 Alt | FctKey | 0xbf, /* (Alt) F2 */
2880 Alt | FctKey | 0xc0, /* (Alt) F3 */
2881 Alt | FctKey | 0xc1, /* (Alt) F4 */
2882 Alt | FctKey | 0xc2, /* (Alt) F5 */
2883 Alt | FctKey | 0xc3, /* (Alt) F6 */
2884 Alt | FctKey | 0xc4, /* (Alt) F7 */
2885 Alt | FctKey | 0xc5, /* (Alt) F8 */
2887 /* --------------- 70 to 7f --------------- */
2888 Alt | FctKey | 0xc6, /* (Alt) F9 */
2889 Alt | FctKey | 0xc7, /* (Alt) F10 */
2890 Ctrl | FctKey | 0x6d, /* (Ctrl) Sys Rq */
2891 Ctrl | KeyPad | 4, /* (Ctrl) Left */
2892 Ctrl | KeyPad | 6, /* (Ctrl) Right */
2893 Ctrl | KeyPad | 1, /* (Ctrl) End */
2894 Ctrl | KeyPad | 3, /* (Ctrl) Page Down */
2895 Ctrl | KeyPad | 7, /* (Ctrl) Home */
2896 Alt | Map | 1, /* '1' */
2897 Alt | Map | 2, /* '2' */
2898 Alt | Map | 3, /* '3' */
2899 Alt | Map | 4, /* '4' */
2900 Alt | Map | 5, /* '5' */
2901 Alt | Map | 6, /* '6' */
2902 Alt | Map | 7, /* '7' */
2903 Alt | Map | 8, /* '8' */
2905 /* --------------- 80 to 8f --------------- */
2906 Alt | Map | 9, /* '9' */
2907 Alt | Map | 10, /* '0' */
2908 Alt | Map | 11, /* '-' */
2909 Alt | Map | 12, /* '=' */
2910 Ctrl | KeyPad | 9, /* (Ctrl) Page Up */
2911 FctKey | 0xc8, /* F11 */
2912 FctKey | 0xc9, /* F12 */
2913 Shift | FctKey | 0xc8, /* (Shift) F11 */
2914 Shift | FctKey | 0xc9, /* (Shift) F12 */
2915 Ctrl | FctKey | 0xc8, /* (Ctrl) F11 */
2916 Ctrl | FctKey | 0xc9, /* (Ctrl) F12 */
2917 Alt | FctKey | 0xc8, /* (Alt) F11 */
2918 Alt | FctKey | 0xc9, /* (Alt) F12 */
2919 Ctrl | KeyPad | 8, /* (Ctrl) Up */
2920 Ctrl | Grey | 2, /* (Ctrl) Grey - */
2921 Ctrl | KeyPad | 5, /* (Ctrl) Keypad 5 */
2923 /* --------------- 90 to 9f --------------- */
2924 Ctrl | Grey | 3, /* (Ctrl) Grey + */
2925 Ctrl | KeyPad | 2, /* (Ctrl) Down */
2926 Ctrl | KeyPad | 0, /* (Ctrl) Insert */
2927 Ctrl | KeyPad | 10, /* (Ctrl) Delete */
2928 Ctrl | FctKey | 0x09, /* (Ctrl) Tab */
2929 Ctrl | Grey | 0, /* (Ctrl) Grey / */
2930 Ctrl | Grey | 1, /* (Ctrl) Grey * */
2931 Alt | FctKey | 0x50, /* (Alt) Home */
2932 Alt | FctKey | 0x52, /* (Alt) Up */
2933 Alt | FctKey | 0x55, /* (Alt) Page Up */
2934 Ignore, /* NO KEY */
2935 Alt | FctKey | 0x51, /* (Alt) Left */
2936 Ignore, /* NO KEY */
2937 Alt | FctKey | 0x53, /* (Alt) Right */
2938 Ignore, /* NO KEY */
2939 Alt | FctKey | 0x57, /* (Alt) End */
2941 /* --------------- a0 to af --------------- */
2942 Alt | KeyPad | 2, /* (Alt) Down */
2943 Alt | KeyPad | 3, /* (Alt) Page Down */
2944 Alt | KeyPad | 0, /* (Alt) Insert */
2945 Alt | KeyPad | 10, /* (Alt) Delete */
2946 Alt | Grey | 0, /* (Alt) Grey / */
2947 Alt | FctKey | 0x09, /* (Alt) Tab */
2948 Alt | Grey | 4 /* (Alt) Keypad Enter */
2951 /* These bit-positions corresponds to values returned by BIOS */
2952 #define SHIFT_P 0x0003 /* two bits! */
2953 #define CTRL_P 0x0004
2954 #define ALT_P 0x0008
2955 #define SCRLOCK_P 0x0010
2956 #define NUMLOCK_P 0x0020
2957 #define CAPSLOCK_P 0x0040
2958 #define ALT_GR_P 0x0800
2959 #define SUPER_P 0x4000 /* pseudo */
2960 #define HYPER_P 0x8000 /* pseudo */
2962 static int
2963 dos_get_modifiers (keymask)
2964 int *keymask;
2966 union REGS regs;
2967 int mask;
2968 int modifiers = 0;
2970 /* Calculate modifier bits */
2971 regs.h.ah = extended_kbd ? 0x12 : 0x02;
2972 int86 (0x16, &regs, &regs);
2974 if (!extended_kbd)
2976 mask = regs.h.al & (SHIFT_P | CTRL_P | ALT_P |
2977 SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
2979 else
2981 mask = regs.h.al & (SHIFT_P |
2982 SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
2984 /* Do not break international keyboard support. */
2985 /* When Keyb.Com is loaded, the right Alt key is */
2986 /* used for accessing characters like { and } */
2987 if (regs.h.ah & 2) /* Left ALT pressed ? */
2988 mask |= ALT_P;
2990 if ((regs.h.ah & 8) != 0) /* Right ALT pressed ? */
2992 mask |= ALT_GR_P;
2993 if (dos_hyper_key == 1)
2995 mask |= HYPER_P;
2996 modifiers |= hyper_modifier;
2998 else if (dos_super_key == 1)
3000 mask |= SUPER_P;
3001 modifiers |= super_modifier;
3003 else if (!international_keyboard)
3005 /* If Keyb.Com is NOT installed, let Right Alt behave
3006 like the Left Alt. */
3007 mask &= ~ALT_GR_P;
3008 mask |= ALT_P;
3012 if (regs.h.ah & 1) /* Left CTRL pressed ? */
3013 mask |= CTRL_P;
3015 if (regs.h.ah & 4) /* Right CTRL pressed ? */
3017 if (dos_hyper_key == 2)
3019 mask |= HYPER_P;
3020 modifiers |= hyper_modifier;
3022 else if (dos_super_key == 2)
3024 mask |= SUPER_P;
3025 modifiers |= super_modifier;
3027 else
3028 mask |= CTRL_P;
3032 if (mask & SHIFT_P)
3033 modifiers |= shift_modifier;
3034 if (mask & CTRL_P)
3035 modifiers |= ctrl_modifier;
3036 if (mask & ALT_P)
3037 modifiers |= meta_modifier;
3039 if (keymask)
3040 *keymask = mask;
3041 return modifiers;
3044 #define NUM_RECENT_DOSKEYS (100)
3045 int recent_doskeys_index; /* Index for storing next element into recent_doskeys */
3046 int total_doskeys; /* Total number of elements stored into recent_doskeys */
3047 Lisp_Object recent_doskeys; /* A vector, holding the last 100 keystrokes */
3049 DEFUN ("recent-doskeys", Frecent_doskeys, Srecent_doskeys, 0, 0, 0,
3050 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3051 Each input key receives two values in this vector: first the ASCII code,\n\
3052 and then the scan code.")
3055 Lisp_Object *keys = XVECTOR (recent_doskeys)->contents;
3056 Lisp_Object val;
3058 if (total_doskeys < NUM_RECENT_DOSKEYS)
3059 return Fvector (total_doskeys, keys);
3060 else
3062 val = Fvector (NUM_RECENT_DOSKEYS, keys);
3063 bcopy (keys + recent_doskeys_index,
3064 XVECTOR (val)->contents,
3065 (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
3066 bcopy (keys,
3067 XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
3068 recent_doskeys_index * sizeof (Lisp_Object));
3069 return val;
3073 /* Get a char from keyboard. Function keys are put into the event queue. */
3074 static int
3075 dos_rawgetc ()
3077 struct input_event event;
3078 union REGS regs;
3080 #ifndef HAVE_X_WINDOWS
3081 /* Maybe put the cursor where it should be. */
3082 IT_cmgoto (SELECTED_FRAME());
3083 #endif
3085 /* The following condition is equivalent to `kbhit ()', except that
3086 it uses the bios to do its job. This pleases DESQview/X. */
3087 while ((regs.h.ah = extended_kbd ? 0x11 : 0x01),
3088 int86 (0x16, &regs, &regs),
3089 (regs.x.flags & 0x40) == 0)
3091 union REGS regs;
3092 register unsigned char c;
3093 int sc, code = -1, mask, kp_mode;
3094 int modifiers;
3096 regs.h.ah = extended_kbd ? 0x10 : 0x00;
3097 int86 (0x16, &regs, &regs);
3098 c = regs.h.al;
3099 sc = regs.h.ah;
3101 total_doskeys += 2;
3102 XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
3103 = make_number (c);
3104 if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
3105 recent_doskeys_index = 0;
3106 XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
3107 = make_number (sc);
3108 if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
3109 recent_doskeys_index = 0;
3111 modifiers = dos_get_modifiers (&mask);
3113 #ifndef HAVE_X_WINDOWS
3114 if (!NILP (Vdos_display_scancodes))
3116 char buf[11];
3117 sprintf (buf, "%02x:%02x*%04x",
3118 (unsigned) (sc&0xff), (unsigned) c, mask);
3119 dos_direct_output (screen_size_Y - 2, screen_size_X - 12, buf, 10);
3121 #endif
3123 if (sc == 0xe0)
3125 switch (c)
3127 case 10: /* Ctrl Grey Enter */
3128 code = Ctrl | Grey | 4;
3129 break;
3130 case 13: /* Grey Enter */
3131 code = Grey | 4;
3132 break;
3133 case '/': /* Grey / */
3134 code = Grey | 0;
3135 break;
3136 default:
3137 continue;
3139 c = 0;
3141 else
3143 /* Try the keyboard-private translation table first. */
3144 if (keyboard->translate_table)
3146 struct kbd_translate *p = keyboard->translate_table;
3148 while (p->sc)
3150 if (p->sc == sc && p->ch == c)
3152 code = p->code;
3153 break;
3155 p++;
3158 /* If the private table didn't translate it, use the general
3159 one. */
3160 if (code == -1)
3162 if (sc >= (sizeof (ibmpc_translate_map) / sizeof (short)))
3163 continue;
3164 if ((code = ibmpc_translate_map[sc]) == Ignore)
3165 continue;
3169 if (c == 0)
3171 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3172 Emacs is ready to read a key. Therefore, if they press
3173 `Alt-x' when Emacs is busy, by the time we get to
3174 `dos_get_modifiers', they might have already released the
3175 Alt key, and Emacs gets just `x', which is BAD.
3176 However, for keys with the `Map' property set, the ASCII
3177 code returns zero iff Alt is pressed. So, when we DON'T
3178 have to support international_keyboard, we don't have to
3179 distinguish between the left and right Alt keys, and we
3180 can set the META modifier for any keys with the `Map'
3181 property if they return zero ASCII code (c = 0). */
3182 if ( (code & Alt)
3183 || ( (code & 0xf000) == Map && !international_keyboard))
3184 modifiers |= meta_modifier;
3185 if (code & Ctrl)
3186 modifiers |= ctrl_modifier;
3187 if (code & Shift)
3188 modifiers |= shift_modifier;
3191 switch (code & 0xf000)
3193 case ModFct:
3194 if (c && !(mask & (SHIFT_P | ALT_P | CTRL_P | HYPER_P | SUPER_P)))
3195 return c;
3196 c = 0; /* Special */
3198 case FctKey:
3199 if (c != 0)
3200 return c;
3202 case Special:
3203 code |= 0xff00;
3204 break;
3206 case Normal:
3207 if (sc == 0)
3209 if (c == 0) /* ctrl-break */
3210 continue;
3211 return c; /* ALT-nnn */
3213 if (!keyboard_map_all)
3215 if (c != ' ')
3216 return c;
3217 code = c;
3218 break;
3221 case Map:
3222 if (c && !(mask & ALT_P) && !((mask & SHIFT_P) && (mask & CTRL_P)))
3223 if (!keyboard_map_all)
3224 return c;
3226 code &= 0xff;
3227 if (mask & ALT_P && code <= 10 && code > 0 && dos_keypad_mode & 0x200)
3228 mask |= SHIFT_P; /* ALT-1 => M-! etc. */
3230 if (mask & SHIFT_P)
3232 code = keyboard->shifted[code];
3233 mask -= SHIFT_P;
3234 modifiers &= ~shift_modifier;
3236 else
3237 if ((mask & ALT_GR_P) && keyboard->alt_gr && keyboard->alt_gr[code] != ' ')
3238 code = keyboard->alt_gr[code];
3239 else
3240 code = keyboard->unshifted[code];
3241 break;
3243 case KeyPad:
3244 code &= 0xff;
3245 if (c == 0xe0) /* edit key */
3246 kp_mode = 3;
3247 else
3248 if ((mask & (NUMLOCK_P|CTRL_P|SHIFT_P|ALT_P)) == NUMLOCK_P) /* numlock on */
3249 kp_mode = dos_keypad_mode & 0x03;
3250 else
3251 kp_mode = (dos_keypad_mode >> 4) & 0x03;
3253 switch (kp_mode)
3255 case 0:
3256 if (code == 10 && dos_decimal_point)
3257 return dos_decimal_point;
3258 return keypad_translate_map[code].char_code;
3260 case 1:
3261 code = 0xff00 | keypad_translate_map[code].keypad_code;
3262 break;
3264 case 2:
3265 code = keypad_translate_map[code].meta_code;
3266 modifiers = meta_modifier;
3267 break;
3269 case 3:
3270 code = 0xff00 | keypad_translate_map[code].editkey_code;
3271 break;
3273 break;
3275 case Grey:
3276 code &= 0xff;
3277 kp_mode = ((mask & (NUMLOCK_P|CTRL_P|SHIFT_P|ALT_P)) == NUMLOCK_P) ? 0x04 : 0x40;
3278 if (dos_keypad_mode & kp_mode)
3279 code = 0xff00 | grey_key_translate_map[code].keypad_code;
3280 else
3281 code = grey_key_translate_map[code].char_code;
3282 break;
3285 make_event:
3286 if (code == 0)
3287 continue;
3289 if (code >= 0x100)
3290 event.kind = non_ascii_keystroke;
3291 else
3292 event.kind = ascii_keystroke;
3293 event.code = code;
3294 event.modifiers = modifiers;
3295 event.frame_or_window = selected_frame;
3296 event.arg = Qnil;
3297 event.timestamp = event_timestamp ();
3298 kbd_buffer_store_event (&event);
3301 if (have_mouse > 0 && !mouse_preempted)
3303 int but, press, x, y, ok;
3304 int mouse_prev_x = mouse_last_x, mouse_prev_y = mouse_last_y;
3306 /* Check for mouse movement *before* buttons. */
3307 mouse_check_moved ();
3309 /* If the mouse moved from the spot of its last sighting, we
3310 might need to update mouse highlight. */
3311 if (mouse_last_x != mouse_prev_x || mouse_last_y != mouse_prev_y)
3313 previous_help_echo = help_echo;
3314 help_echo = help_echo_object = help_echo_window = Qnil;
3315 help_echo_pos = -1;
3316 IT_note_mouse_highlight (SELECTED_FRAME(),
3317 mouse_last_x, mouse_last_y);
3318 /* If the contents of the global variable help_echo has
3319 changed, generate a HELP_EVENT. */
3320 if (!NILP (help_echo) || !NILP (previous_help_echo))
3322 /* HELP_EVENT takes 2 events in the event loop. */
3323 event.kind = HELP_EVENT;
3324 event.frame_or_window = selected_frame;
3325 event.arg = help_echo_object;
3326 event.x = make_number (help_echo_pos);
3327 event.timestamp = event_timestamp ();
3328 event.code = 0;
3329 kbd_buffer_store_event (&event);
3330 if (WINDOWP (help_echo_window))
3331 event.frame_or_window = help_echo_window;
3332 event.arg = help_echo;
3333 event.code = 1;
3334 kbd_buffer_store_event (&event);
3338 for (but = 0; but < NUM_MOUSE_BUTTONS; but++)
3339 for (press = 0; press < 2; press++)
3341 int button_num = but;
3343 if (press)
3344 ok = mouse_pressed (but, &x, &y);
3345 else
3346 ok = mouse_released (but, &x, &y);
3347 if (ok)
3349 /* Allow a simultaneous press/release of Mouse-1 and
3350 Mouse-2 to simulate Mouse-3 on two-button mice. */
3351 if (mouse_button_count == 2 && but < 2)
3353 int x2, y2; /* don't clobber original coordinates */
3355 /* If only one button is pressed, wait 100 msec and
3356 check again. This way, Speedy Gonzales isn't
3357 punished, while the slow get their chance. */
3358 if (press && mouse_pressed (1-but, &x2, &y2)
3359 || !press && mouse_released (1-but, &x2, &y2))
3360 button_num = 2;
3361 else
3363 delay (100);
3364 if (press && mouse_pressed (1-but, &x2, &y2)
3365 || !press && mouse_released (1-but, &x2, &y2))
3366 button_num = 2;
3370 event.kind = mouse_click;
3371 event.code = button_num;
3372 event.modifiers = dos_get_modifiers (0)
3373 | (press ? down_modifier : up_modifier);
3374 event.x = x;
3375 event.y = y;
3376 event.frame_or_window = selected_frame;
3377 event.arg = Qnil;
3378 event.timestamp = event_timestamp ();
3379 kbd_buffer_store_event (&event);
3384 return -1;
3387 static int prev_get_char = -1;
3389 /* Return 1 if a key is ready to be read without suspending execution. */
3391 dos_keysns ()
3393 if (prev_get_char != -1)
3394 return 1;
3395 else
3396 return ((prev_get_char = dos_rawgetc ()) != -1);
3399 /* Read a key. Return -1 if no key is ready. */
3401 dos_keyread ()
3403 if (prev_get_char != -1)
3405 int c = prev_get_char;
3406 prev_get_char = -1;
3407 return c;
3409 else
3410 return dos_rawgetc ();
3413 #ifndef HAVE_X_WINDOWS
3414 /* See xterm.c for more info. */
3415 void
3416 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
3417 FRAME_PTR f;
3418 register int pix_x, pix_y;
3419 register int *x, *y;
3420 XRectangle *bounds;
3421 int noclip;
3423 if (bounds) abort ();
3425 /* Ignore clipping. */
3427 *x = pix_x;
3428 *y = pix_y;
3431 void
3432 glyph_to_pixel_coords (f, x, y, pix_x, pix_y)
3433 FRAME_PTR f;
3434 register int x, y;
3435 register int *pix_x, *pix_y;
3437 *pix_x = x;
3438 *pix_y = y;
3441 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3442 for now.
3444 Actually, I don't know the meaning of all the parameters of the functions
3445 here -- I only know how they are called by xmenu.c. I could of course
3446 grab the nearest Xlib manual (down the hall, second-to-last door on the
3447 left), but I don't think it's worth the effort. */
3449 /* These hold text of the current and the previous menu help messages. */
3450 static char *menu_help_message, *prev_menu_help_message;
3451 /* Pane number and item number of the menu item which generated the
3452 last menu help message. */
3453 static int menu_help_paneno, menu_help_itemno;
3455 static XMenu *
3456 IT_menu_create ()
3458 XMenu *menu;
3460 menu = (XMenu *) xmalloc (sizeof (XMenu));
3461 menu->allocated = menu->count = menu->panecount = menu->width = 0;
3462 return menu;
3465 /* Allocate some (more) memory for MENU ensuring that there is room for one
3466 for item. */
3468 static void
3469 IT_menu_make_room (XMenu *menu)
3471 if (menu->allocated == 0)
3473 int count = menu->allocated = 10;
3474 menu->text = (char **) xmalloc (count * sizeof (char *));
3475 menu->submenu = (XMenu **) xmalloc (count * sizeof (XMenu *));
3476 menu->panenumber = (int *) xmalloc (count * sizeof (int));
3477 menu->help_text = (char **) xmalloc (count * sizeof (char *));
3479 else if (menu->allocated == menu->count)
3481 int count = menu->allocated = menu->allocated + 10;
3482 menu->text
3483 = (char **) xrealloc (menu->text, count * sizeof (char *));
3484 menu->submenu
3485 = (XMenu **) xrealloc (menu->submenu, count * sizeof (XMenu *));
3486 menu->panenumber
3487 = (int *) xrealloc (menu->panenumber, count * sizeof (int));
3488 menu->help_text
3489 = (char **) xrealloc (menu->help_text, count * sizeof (char *));
3493 /* Search the given menu structure for a given pane number. */
3495 static XMenu *
3496 IT_menu_search_pane (XMenu *menu, int pane)
3498 int i;
3499 XMenu *try;
3501 for (i = 0; i < menu->count; i++)
3502 if (menu->submenu[i])
3504 if (pane == menu->panenumber[i])
3505 return menu->submenu[i];
3506 if ((try = IT_menu_search_pane (menu->submenu[i], pane)))
3507 return try;
3509 return (XMenu *) 0;
3512 /* Determine how much screen space a given menu needs. */
3514 static void
3515 IT_menu_calc_size (XMenu *menu, int *width, int *height)
3517 int i, h2, w2, maxsubwidth, maxheight;
3519 maxsubwidth = 0;
3520 maxheight = menu->count;
3521 for (i = 0; i < menu->count; i++)
3523 if (menu->submenu[i])
3525 IT_menu_calc_size (menu->submenu[i], &w2, &h2);
3526 if (w2 > maxsubwidth) maxsubwidth = w2;
3527 if (i + h2 > maxheight) maxheight = i + h2;
3530 *width = menu->width + maxsubwidth;
3531 *height = maxheight;
3534 /* Display MENU at (X,Y) using FACES. */
3536 static void
3537 IT_menu_display (XMenu *menu, int y, int x, int pn, int *faces, int disp_help)
3539 int i, j, face, width;
3540 struct glyph *text, *p;
3541 char *q;
3542 int mx, my;
3543 int enabled, mousehere;
3544 int row, col;
3545 struct frame *sf = SELECTED_FRAME();
3547 menu_help_message = NULL;
3549 width = menu->width;
3550 text = (struct glyph *) xmalloc ((width + 2) * sizeof (struct glyph));
3551 ScreenGetCursor (&row, &col);
3552 mouse_get_xy (&mx, &my);
3553 IT_update_begin (sf);
3554 for (i = 0; i < menu->count; i++)
3556 int max_width = width + 2;
3558 IT_cursor_to (y + i, x);
3559 enabled
3560 = (!menu->submenu[i] && menu->panenumber[i]) || (menu->submenu[i]);
3561 mousehere = (y + i == my && x <= mx && mx < x + width + 2);
3562 face = faces[enabled + mousehere * 2];
3563 /* The following if clause means that we display the menu help
3564 strings even if the menu item is currently disabled. */
3565 if (disp_help && enabled + mousehere * 2 >= 2)
3567 menu_help_message = menu->help_text[i];
3568 menu_help_paneno = pn - 1;
3569 menu_help_itemno = i;
3571 p = text;
3572 SET_CHAR_GLYPH (*p, ' ', face, 0);
3573 p++;
3574 for (j = 0, q = menu->text[i]; *q; j++)
3576 if (*q > 26)
3578 SET_CHAR_GLYPH (*p, *q++, face, 0);
3579 p++;
3581 else /* make '^x' */
3583 SET_CHAR_GLYPH (*p, '^', face, 0);
3584 p++;
3585 j++;
3586 SET_CHAR_GLYPH (*p, *q++ + 64, face, 0);
3587 p++;
3590 /* Don't let the menu text overflow into the next screen row. */
3591 if (x + max_width > screen_size_X)
3593 max_width = screen_size_X - x;
3594 text[max_width - 1].u.ch = '$'; /* indicate it's truncated */
3596 for (; j < max_width - 2; j++, p++)
3597 SET_CHAR_GLYPH (*p, ' ', face, 0);
3599 SET_CHAR_GLYPH (*p, menu->submenu[i] ? 16 : ' ', face, 0);
3600 p++;
3601 IT_write_glyphs (text, max_width);
3603 IT_update_end (sf);
3604 IT_cursor_to (row, col);
3605 xfree (text);
3608 /* --------------------------- X Menu emulation ---------------------- */
3610 /* Report availability of menus. */
3613 have_menus_p ()
3615 return 1;
3618 /* Create a brand new menu structure. */
3620 XMenu *
3621 XMenuCreate (Display *foo1, Window foo2, char *foo3)
3623 return IT_menu_create ();
3626 /* Create a new pane and place it on the outer-most level. It is not
3627 clear that it should be placed out there, but I don't know what else
3628 to do. */
3631 XMenuAddPane (Display *foo, XMenu *menu, char *txt, int enable)
3633 int len;
3634 char *p;
3636 if (!enable)
3637 abort ();
3639 IT_menu_make_room (menu);
3640 menu->submenu[menu->count] = IT_menu_create ();
3641 menu->text[menu->count] = txt;
3642 menu->panenumber[menu->count] = ++menu->panecount;
3643 menu->help_text[menu->count] = NULL;
3644 menu->count++;
3646 /* Adjust length for possible control characters (which will
3647 be written as ^x). */
3648 for (len = strlen (txt), p = txt; *p; p++)
3649 if (*p < 27)
3650 len++;
3652 if (len > menu->width)
3653 menu->width = len;
3655 return menu->panecount;
3658 /* Create a new item in a menu pane. */
3661 XMenuAddSelection (Display *bar, XMenu *menu, int pane,
3662 int foo, char *txt, int enable, char *help_text)
3664 int len;
3665 char *p;
3667 if (pane)
3668 if (!(menu = IT_menu_search_pane (menu, pane)))
3669 return XM_FAILURE;
3670 IT_menu_make_room (menu);
3671 menu->submenu[menu->count] = (XMenu *) 0;
3672 menu->text[menu->count] = txt;
3673 menu->panenumber[menu->count] = enable;
3674 menu->help_text[menu->count] = help_text;
3675 menu->count++;
3677 /* Adjust length for possible control characters (which will
3678 be written as ^x). */
3679 for (len = strlen (txt), p = txt; *p; p++)
3680 if (*p < 27)
3681 len++;
3683 if (len > menu->width)
3684 menu->width = len;
3686 return XM_SUCCESS;
3689 /* Decide where the menu would be placed if requested at (X,Y). */
3691 void
3692 XMenuLocate (Display *foo0, XMenu *menu, int foo1, int foo2, int x, int y,
3693 int *ulx, int *uly, int *width, int *height)
3695 IT_menu_calc_size (menu, width, height);
3696 *ulx = x + 1;
3697 *uly = y;
3698 *width += 2;
3701 struct IT_menu_state
3703 void *screen_behind;
3704 XMenu *menu;
3705 int pane;
3706 int x, y;
3710 /* Display menu, wait for user's response, and return that response. */
3713 XMenuActivate (Display *foo, XMenu *menu, int *pane, int *selidx,
3714 int x0, int y0, unsigned ButtonMask, char **txt,
3715 void (*help_callback)(char *, int, int))
3717 struct IT_menu_state *state;
3718 int statecount;
3719 int x, y, i, b;
3720 int screensize;
3721 int faces[4];
3722 Lisp_Object selectface;
3723 int leave, result, onepane;
3724 int title_faces[4]; /* face to display the menu title */
3725 int buffers_num_deleted = 0;
3726 struct frame *sf = SELECTED_FRAME();
3727 Lisp_Object saved_echo_area_message;
3729 /* Just in case we got here without a mouse present... */
3730 if (have_mouse <= 0)
3731 return XM_IA_SELECT;
3732 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3733 around the display. */
3734 if (x0 <= 0)
3735 x0 = 1;
3736 if (y0 <= 0)
3737 y0 = 1;
3739 /* We will process all the mouse events directly, so we had
3740 better prevent dos_rawgetc from stealing them from us. */
3741 mouse_preempted++;
3743 state = alloca (menu->panecount * sizeof (struct IT_menu_state));
3744 screensize = screen_size * 2;
3745 faces[0]
3746 = lookup_derived_face (sf, intern ("msdos-menu-passive-face"),
3747 0, DEFAULT_FACE_ID);
3748 faces[1]
3749 = lookup_derived_face (sf, intern ("msdos-menu-active-face"),
3750 0, DEFAULT_FACE_ID);
3751 selectface = intern ("msdos-menu-select-face");
3752 faces[2] = lookup_derived_face (sf, selectface,
3753 0, faces[0]);
3754 faces[3] = lookup_derived_face (sf, selectface,
3755 0, faces[1]);
3757 /* Make sure the menu title is always displayed with
3758 `msdos-menu-active-face', no matter where the mouse pointer is. */
3759 for (i = 0; i < 4; i++)
3760 title_faces[i] = faces[3];
3762 statecount = 1;
3764 /* Don't let the title for the "Buffers" popup menu include a
3765 digit (which is ugly).
3767 This is a terrible kludge, but I think the "Buffers" case is
3768 the only one where the title includes a number, so it doesn't
3769 seem to be necessary to make this more general. */
3770 if (strncmp (menu->text[0], "Buffers 1", 9) == 0)
3772 menu->text[0][7] = '\0';
3773 buffers_num_deleted = 1;
3776 /* We need to save the current echo area message, so that we could
3777 restore it below, before we exit. See the commentary below,
3778 before the call to message_with_string. */
3779 saved_echo_area_message = Fcurrent_message ();
3780 state[0].menu = menu;
3781 mouse_off ();
3782 ScreenRetrieve (state[0].screen_behind = xmalloc (screensize));
3784 /* Turn off the cursor. Otherwise it shows through the menu
3785 panes, which is ugly. */
3786 IT_display_cursor (0);
3788 /* Display the menu title. */
3789 IT_menu_display (menu, y0 - 1, x0 - 1, 1, title_faces, 0);
3790 if (buffers_num_deleted)
3791 menu->text[0][7] = ' ';
3792 if ((onepane = menu->count == 1 && menu->submenu[0]))
3794 menu->width = menu->submenu[0]->width;
3795 state[0].menu = menu->submenu[0];
3797 else
3799 state[0].menu = menu;
3801 state[0].x = x0 - 1;
3802 state[0].y = y0;
3803 state[0].pane = onepane;
3805 mouse_last_x = -1; /* A hack that forces display. */
3806 leave = 0;
3807 while (!leave)
3809 if (!mouse_visible) mouse_on ();
3810 mouse_check_moved ();
3811 if (sf->mouse_moved)
3813 sf->mouse_moved = 0;
3814 result = XM_IA_SELECT;
3815 mouse_get_xy (&x, &y);
3816 for (i = 0; i < statecount; i++)
3817 if (state[i].x <= x && x < state[i].x + state[i].menu->width + 2)
3819 int dy = y - state[i].y;
3820 if (0 <= dy && dy < state[i].menu->count)
3822 if (!state[i].menu->submenu[dy])
3823 if (state[i].menu->panenumber[dy])
3824 result = XM_SUCCESS;
3825 else
3826 result = XM_IA_SELECT;
3827 *pane = state[i].pane - 1;
3828 *selidx = dy;
3829 /* We hit some part of a menu, so drop extra menus that
3830 have been opened. That does not include an open and
3831 active submenu. */
3832 if (i != statecount - 2
3833 || state[i].menu->submenu[dy] != state[i+1].menu)
3834 while (i != statecount - 1)
3836 statecount--;
3837 mouse_off ();
3838 ScreenUpdate (state[statecount].screen_behind);
3839 if (screen_virtual_segment)
3840 dosv_refresh_virtual_screen (0, screen_size);
3841 xfree (state[statecount].screen_behind);
3843 if (i == statecount - 1 && state[i].menu->submenu[dy])
3845 IT_menu_display (state[i].menu,
3846 state[i].y,
3847 state[i].x,
3848 state[i].pane,
3849 faces, 1);
3850 state[statecount].menu = state[i].menu->submenu[dy];
3851 state[statecount].pane = state[i].menu->panenumber[dy];
3852 mouse_off ();
3853 ScreenRetrieve (state[statecount].screen_behind
3854 = xmalloc (screensize));
3855 state[statecount].x
3856 = state[i].x + state[i].menu->width + 2;
3857 state[statecount].y = y;
3858 statecount++;
3862 IT_menu_display (state[statecount - 1].menu,
3863 state[statecount - 1].y,
3864 state[statecount - 1].x,
3865 state[statecount - 1].pane,
3866 faces, 1);
3868 else
3870 if ((menu_help_message || prev_menu_help_message)
3871 && menu_help_message != prev_menu_help_message)
3873 help_callback (menu_help_message,
3874 menu_help_paneno, menu_help_itemno);
3875 IT_display_cursor (0);
3876 prev_menu_help_message = menu_help_message;
3878 /* We are busy-waiting for the mouse to move, so let's be nice
3879 to other Windows applications by releasing our time slice. */
3880 __dpmi_yield ();
3882 for (b = 0; b < mouse_button_count && !leave; b++)
3884 /* Only leave if user both pressed and released the mouse, and in
3885 that order. This avoids popping down the menu pane unless
3886 the user is really done with it. */
3887 if (mouse_pressed (b, &x, &y))
3889 while (mouse_button_depressed (b, &x, &y))
3890 __dpmi_yield ();
3891 leave = 1;
3893 (void) mouse_released (b, &x, &y);
3897 mouse_off ();
3898 ScreenUpdate (state[0].screen_behind);
3899 if (screen_virtual_segment)
3900 dosv_refresh_virtual_screen (0, screen_size);
3902 /* We have a situation here. ScreenUpdate has just restored the
3903 screen contents as it was before we started drawing this menu.
3904 That includes any echo area message that could have been
3905 displayed back then. (In reality, that echo area message will
3906 almost always be the ``keystroke echo'' that echoes the sequence
3907 of menu items chosen by the user.) However, if the menu had some
3908 help messages, then displaying those messages caused Emacs to
3909 forget about the original echo area message. So when
3910 ScreenUpdate restored it, it created a discrepancy between the
3911 actual screen contents and what Emacs internal data structures
3912 know about it.
3914 To avoid this conflict, we force Emacs to restore the original
3915 echo area message as we found it when we entered this function.
3916 The irony of this is that we then erase the restored message
3917 right away, so the only purpose of restoring it is so that
3918 erasing it works correctly... */
3919 if (! NILP (saved_echo_area_message))
3920 message_with_string ("%s", saved_echo_area_message, 0);
3921 message (0);
3922 while (statecount--)
3923 xfree (state[statecount].screen_behind);
3924 IT_display_cursor (1); /* turn cursor back on */
3925 /* Clean up any mouse events that are waiting inside Emacs event queue.
3926 These events are likely to be generated before the menu was even
3927 displayed, probably because the user pressed and released the button
3928 (which invoked the menu) too quickly. If we don't remove these events,
3929 Emacs will process them after we return and surprise the user. */
3930 discard_mouse_events ();
3931 mouse_clear_clicks ();
3932 if (!kbd_buffer_events_waiting (1))
3933 clear_input_pending ();
3934 /* Allow mouse events generation by dos_rawgetc. */
3935 mouse_preempted--;
3936 return result;
3939 /* Dispose of a menu. */
3941 void
3942 XMenuDestroy (Display *foo, XMenu *menu)
3944 int i;
3945 if (menu->allocated)
3947 for (i = 0; i < menu->count; i++)
3948 if (menu->submenu[i])
3949 XMenuDestroy (foo, menu->submenu[i]);
3950 xfree (menu->text);
3951 xfree (menu->submenu);
3952 xfree (menu->panenumber);
3953 xfree (menu->help_text);
3955 xfree (menu);
3956 menu_help_message = prev_menu_help_message = NULL;
3960 x_pixel_width (struct frame *f)
3962 return FRAME_WIDTH (f);
3966 x_pixel_height (struct frame *f)
3968 return FRAME_HEIGHT (f);
3970 #endif /* !HAVE_X_WINDOWS */
3972 /* ----------------------- DOS / UNIX conversion --------------------- */
3974 void msdos_downcase_filename (unsigned char *);
3976 /* Destructively turn backslashes into slashes. */
3978 void
3979 dostounix_filename (p)
3980 register char *p;
3982 msdos_downcase_filename (p);
3984 while (*p)
3986 if (*p == '\\')
3987 *p = '/';
3988 p++;
3992 /* Destructively turn slashes into backslashes. */
3994 void
3995 unixtodos_filename (p)
3996 register char *p;
3998 if (p[1] == ':' && *p >= 'A' && *p <= 'Z')
4000 *p += 'a' - 'A';
4001 p += 2;
4004 while (*p)
4006 if (*p == '/')
4007 *p = '\\';
4008 p++;
4012 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4015 getdefdir (drive, dst)
4016 int drive;
4017 char *dst;
4019 char in_path[4], *p = in_path;
4020 int e = errno;
4022 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4023 if (drive != 0)
4025 *p++ = drive + 'A' - 1;
4026 *p++ = ':';
4029 *p++ = '.';
4030 *p = '\0';
4031 errno = 0;
4032 _fixpath (in_path, dst);
4033 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4034 it queries the LFN support, so ignore that error. */
4035 if ((errno && errno != ENOSYS) || *dst == '\0')
4036 return 0;
4038 msdos_downcase_filename (dst);
4040 errno = e;
4041 return 1;
4044 /* Remove all CR's that are followed by a LF. */
4047 crlf_to_lf (n, buf)
4048 register int n;
4049 register unsigned char *buf;
4051 unsigned char *np = buf;
4052 unsigned char *startp = buf;
4053 unsigned char *endp = buf + n;
4055 if (n == 0)
4056 return n;
4057 while (buf < endp - 1)
4059 if (*buf == 0x0d)
4061 if (*(++buf) != 0x0a)
4062 *np++ = 0x0d;
4064 else
4065 *np++ = *buf++;
4067 if (buf < endp)
4068 *np++ = *buf++;
4069 return np - startp;
4072 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4074 /* In DJGPP v2.0, library `write' can call `malloc', which might
4075 cause relocation of the buffer whose address we get in ADDR.
4076 Here is a version of `write' that avoids calling `malloc',
4077 to serve us until such time as the library is fixed.
4078 Actually, what we define here is called `__write', because
4079 `write' is a stub that just jmp's to `__write' (to be
4080 POSIXLY-correct with respect to the global name-space). */
4082 #include <io.h> /* for _write */
4083 #include <libc/dosio.h> /* for __file_handle_modes[] */
4085 static char xbuf[64 * 1024]; /* DOS cannot write more in one chunk */
4087 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4090 __write (int handle, const void *buffer, size_t count)
4092 if (count == 0)
4093 return 0;
4095 if(__file_handle_modes[handle] & O_BINARY)
4096 return _write (handle, buffer, count);
4097 else
4099 char *xbp = xbuf;
4100 const char *bp = buffer;
4101 int total_written = 0;
4102 int nmoved = 0, ncr = 0;
4104 while (count)
4106 /* The next test makes sure there's space for at least 2 more
4107 characters in xbuf[], so both CR and LF can be put there. */
4108 if (xbp < XBUF_END)
4110 if (*bp == '\n')
4112 ncr++;
4113 *xbp++ = '\r';
4115 *xbp++ = *bp++;
4116 nmoved++;
4117 count--;
4119 if (xbp >= XBUF_END || !count)
4121 size_t to_write = nmoved + ncr;
4122 int written = _write (handle, xbuf, to_write);
4124 if (written == -1)
4125 return -1;
4126 else
4127 total_written += nmoved; /* CRs aren't counted in ret value */
4129 /* If some, but not all were written (disk full?), return
4130 an estimate of the total written bytes not counting CRs. */
4131 if (written < to_write)
4132 return total_written - (to_write - written) * nmoved/to_write;
4134 nmoved = 0;
4135 ncr = 0;
4136 xbp = xbuf;
4139 return total_written;
4143 /* A low-level file-renaming function which works around Windows 95 bug.
4144 This is pulled directly out of DJGPP v2.01 library sources, and only
4145 used when you compile with DJGPP v2.0. */
4147 #include <io.h>
4149 int _rename(const char *old, const char *new)
4151 __dpmi_regs r;
4152 int olen = strlen(old) + 1;
4153 int i;
4154 int use_lfn = _USE_LFN;
4155 char tempfile[FILENAME_MAX];
4156 const char *orig = old;
4157 int lfn_fd = -1;
4159 r.x.dx = __tb_offset;
4160 r.x.di = __tb_offset + olen;
4161 r.x.ds = r.x.es = __tb_segment;
4163 if (use_lfn)
4165 /* Windows 95 bug: for some filenames, when you rename
4166 file -> file~ (as in Emacs, to leave a backup), the
4167 short 8+3 alias doesn't change, which effectively
4168 makes OLD and NEW the same file. We must rename
4169 through a temporary file to work around this. */
4171 char *pbase = 0, *p;
4172 static char try_char[] = "abcdefghijklmnopqrstuvwxyz012345789";
4173 int idx = sizeof(try_char) - 1;
4175 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4176 might point to another drive, which will fail the DOS call. */
4177 strcpy(tempfile, old);
4178 for (p = tempfile; *p; p++) /* ensure temporary is on the same drive */
4179 if (*p == '/' || *p == '\\' || *p == ':')
4180 pbase = p;
4181 if (pbase)
4182 pbase++;
4183 else
4184 pbase = tempfile;
4185 strcpy(pbase, "X$$djren$$.$$temp$$");
4189 if (idx <= 0)
4190 return -1;
4191 *pbase = try_char[--idx];
4192 } while (_chmod(tempfile, 0) != -1);
4194 r.x.ax = 0x7156;
4195 _put_path2(tempfile, olen);
4196 _put_path(old);
4197 __dpmi_int(0x21, &r);
4198 if (r.x.flags & 1)
4200 errno = __doserr_to_errno(r.x.ax);
4201 return -1;
4204 /* Now create a file with the original name. This will
4205 ensure that NEW will always have a 8+3 alias
4206 different from that of OLD. (Seems to be required
4207 when NameNumericTail in the Registry is set to 0.) */
4208 lfn_fd = _creat(old, 0);
4210 olen = strlen(tempfile) + 1;
4211 old = tempfile;
4212 r.x.di = __tb_offset + olen;
4215 for (i=0; i<2; i++)
4217 if(use_lfn)
4218 r.x.ax = 0x7156;
4219 else
4220 r.h.ah = 0x56;
4221 _put_path2(new, olen);
4222 _put_path(old);
4223 __dpmi_int(0x21, &r);
4224 if(r.x.flags & 1)
4226 if (r.x.ax == 5 && i == 0) /* access denied */
4227 remove(new); /* and try again */
4228 else
4230 errno = __doserr_to_errno(r.x.ax);
4232 /* Restore to original name if we renamed it to temporary. */
4233 if (use_lfn)
4235 if (lfn_fd != -1)
4237 _close (lfn_fd);
4238 remove (orig);
4240 _put_path2(orig, olen);
4241 _put_path(tempfile);
4242 r.x.ax = 0x7156;
4243 __dpmi_int(0x21, &r);
4245 return -1;
4248 else
4249 break;
4252 /* Success. Delete the file possibly created to work
4253 around the Windows 95 bug. */
4254 if (lfn_fd != -1)
4255 return (_close (lfn_fd) == 0) ? remove (orig) : -1;
4256 return 0;
4259 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4261 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names, Smsdos_long_file_names,
4262 0, 0, 0,
4263 "Return non-nil if long file names are supported on MSDOS.")
4266 return (_USE_LFN ? Qt : Qnil);
4269 /* Convert alphabetic characters in a filename to lower-case. */
4271 void
4272 msdos_downcase_filename (p)
4273 register unsigned char *p;
4275 /* Always lower-case drive letters a-z, even if the filesystem
4276 preserves case in filenames.
4277 This is so MSDOS filenames could be compared by string comparison
4278 functions that are case-sensitive. Even case-preserving filesystems
4279 do not distinguish case in drive letters. */
4280 if (p[1] == ':' && *p >= 'A' && *p <= 'Z')
4282 *p += 'a' - 'A';
4283 p += 2;
4286 /* Under LFN we expect to get pathnames in their true case. */
4287 if (NILP (Fmsdos_long_file_names ()))
4288 for ( ; *p; p++)
4289 if (*p >= 'A' && *p <= 'Z')
4290 *p += 'a' - 'A';
4293 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename, Smsdos_downcase_filename,
4294 1, 1, 0,
4295 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4296 When long filenames are supported, doesn't change FILENAME.\n\
4297 If FILENAME is not a string, returns nil.\n\
4298 The argument object is never altered--the value is a copy.")
4299 (filename)
4300 Lisp_Object filename;
4302 Lisp_Object tem;
4304 if (! STRINGP (filename))
4305 return Qnil;
4307 tem = Fcopy_sequence (filename);
4308 msdos_downcase_filename (XSTRING (tem)->data);
4309 return tem;
4312 /* The Emacs root directory as determined by init_environment. */
4314 static char emacsroot[MAXPATHLEN];
4316 char *
4317 rootrelativepath (rel)
4318 char *rel;
4320 static char result[MAXPATHLEN + 10];
4322 strcpy (result, emacsroot);
4323 strcat (result, "/");
4324 strcat (result, rel);
4325 return result;
4328 /* Define a lot of environment variables if not already defined. Don't
4329 remove anything unless you know what you're doing -- lots of code will
4330 break if one or more of these are missing. */
4332 void
4333 init_environment (argc, argv, skip_args)
4334 int argc;
4335 char **argv;
4336 int skip_args;
4338 char *s, *t, *root;
4339 int len;
4340 static const char * const tempdirs[] = {
4341 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4343 int i;
4344 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
4346 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4347 temporary files and assume "/tmp" if $TMPDIR is unset, which
4348 will break on DOS/Windows. Refuse to work if we cannot find
4349 a directory, not even "c:/", usable for that purpose. */
4350 for (i = 0; i < imax ; i++)
4352 const char *tmp = tempdirs[i];
4354 if (*tmp == '$')
4355 tmp = getenv (tmp + 1);
4356 /* Note that `access' can lie to us if the directory resides on a
4357 read-only filesystem, like CD-ROM or a write-protected floppy.
4358 The only way to be really sure is to actually create a file and
4359 see if it succeeds. But I think that's too much to ask. */
4360 if (tmp && access (tmp, D_OK) == 0)
4362 setenv ("TMPDIR", tmp, 1);
4363 break;
4366 if (i >= imax)
4367 cmd_error_internal
4368 (Fcons (Qerror,
4369 Fcons (build_string ("no usable temporary directories found!!"),
4370 Qnil)),
4371 "While setting TMPDIR: ");
4373 /* Note the startup time, so we know not to clear the screen if we
4374 exit immediately; see IT_reset_terminal_modes.
4375 (Yes, I know `clock' returns zero the first time it's called, but
4376 I do this anyway, in case some wiseguy changes that at some point.) */
4377 startup_time = clock ();
4379 /* Find our root from argv[0]. Assuming argv[0] is, say,
4380 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4381 root = alloca (MAXPATHLEN + 20);
4382 _fixpath (argv[0], root);
4383 msdos_downcase_filename (root);
4384 len = strlen (root);
4385 while (len > 0 && root[len] != '/' && root[len] != ':')
4386 len--;
4387 root[len] = '\0';
4388 if (len > 4
4389 && (strcmp (root + len - 4, "/bin") == 0
4390 || strcmp (root + len - 4, "/src") == 0)) /* under a debugger */
4391 root[len - 4] = '\0';
4392 else
4393 strcpy (root, "c:/emacs"); /* let's be defensive */
4394 len = strlen (root);
4395 strcpy (emacsroot, root);
4397 /* We default HOME to our root. */
4398 setenv ("HOME", root, 0);
4400 /* We default EMACSPATH to root + "/bin". */
4401 strcpy (root + len, "/bin");
4402 setenv ("EMACSPATH", root, 0);
4404 /* I don't expect anybody to ever use other terminals so the internal
4405 terminal is the default. */
4406 setenv ("TERM", "internal", 0);
4408 #ifdef HAVE_X_WINDOWS
4409 /* Emacs expects DISPLAY to be set. */
4410 setenv ("DISPLAY", "unix:0.0", 0);
4411 #endif
4413 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4414 downcase it and mirror the backslashes. */
4415 s = getenv ("COMSPEC");
4416 if (!s) s = "c:/command.com";
4417 t = alloca (strlen (s) + 1);
4418 strcpy (t, s);
4419 dostounix_filename (t);
4420 setenv ("SHELL", t, 0);
4422 /* PATH is also downcased and backslashes mirrored. */
4423 s = getenv ("PATH");
4424 if (!s) s = "";
4425 t = alloca (strlen (s) + 3);
4426 /* Current directory is always considered part of MsDos's path but it is
4427 not normally mentioned. Now it is. */
4428 strcat (strcpy (t, ".;"), s);
4429 dostounix_filename (t); /* Not a single file name, but this should work. */
4430 setenv ("PATH", t, 1);
4432 /* In some sense all dos users have root privileges, so... */
4433 setenv ("USER", "root", 0);
4434 setenv ("NAME", getenv ("USER"), 0);
4436 /* Time zone determined from country code. To make this possible, the
4437 country code may not span more than one time zone. In other words,
4438 in the USA, you lose. */
4439 if (!getenv ("TZ"))
4440 switch (dos_country_code)
4442 case 31: /* Belgium */
4443 case 32: /* The Netherlands */
4444 case 33: /* France */
4445 case 34: /* Spain */
4446 case 36: /* Hungary */
4447 case 38: /* Yugoslavia (or what's left of it?) */
4448 case 39: /* Italy */
4449 case 41: /* Switzerland */
4450 case 42: /* Tjekia */
4451 case 45: /* Denmark */
4452 case 46: /* Sweden */
4453 case 47: /* Norway */
4454 case 48: /* Poland */
4455 case 49: /* Germany */
4456 /* Daylight saving from last Sunday in March to last Sunday in
4457 September, both at 2AM. */
4458 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4459 break;
4460 case 44: /* United Kingdom */
4461 case 351: /* Portugal */
4462 case 354: /* Iceland */
4463 setenv ("TZ", "GMT+00", 0);
4464 break;
4465 case 81: /* Japan */
4466 case 82: /* Korea */
4467 setenv ("TZ", "JST-09", 0);
4468 break;
4469 case 90: /* Turkey */
4470 case 358: /* Finland */
4471 setenv ("TZ", "EET-02", 0);
4472 break;
4473 case 972: /* Israel */
4474 /* This is an approximation. (For exact rules, use the
4475 `zoneinfo/israel' file which comes with DJGPP, but you need
4476 to install it in `/usr/share/zoneinfo/' directory first.) */
4477 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4478 break;
4480 tzset ();
4485 static int break_stat; /* BREAK check mode status. */
4486 static int stdin_stat; /* stdin IOCTL status. */
4488 #if __DJGPP__ < 2
4490 /* These must be global. */
4491 static _go32_dpmi_seginfo ctrl_break_vector;
4492 static _go32_dpmi_registers ctrl_break_regs;
4493 static int ctrlbreakinstalled = 0;
4495 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4497 void
4498 ctrl_break_func (regs)
4499 _go32_dpmi_registers *regs;
4501 Vquit_flag = Qt;
4504 void
4505 install_ctrl_break_check ()
4507 if (!ctrlbreakinstalled)
4509 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4510 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4511 ctrlbreakinstalled = 1;
4512 ctrl_break_vector.pm_offset = (int) ctrl_break_func;
4513 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector,
4514 &ctrl_break_regs);
4515 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector);
4519 #endif /* __DJGPP__ < 2 */
4521 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4522 control chars by DOS. Determine the keyboard type. */
4525 dos_ttraw ()
4527 union REGS inregs, outregs;
4528 static int first_time = 1;
4530 break_stat = getcbrk ();
4531 setcbrk (0);
4532 #if __DJGPP__ < 2
4533 install_ctrl_break_check ();
4534 #endif
4536 if (first_time)
4538 inregs.h.ah = 0xc0;
4539 int86 (0x15, &inregs, &outregs);
4540 extended_kbd = (!outregs.x.cflag) && (outregs.h.ah == 0);
4542 have_mouse = 0;
4544 if (internal_terminal
4545 #ifdef HAVE_X_WINDOWS
4546 && inhibit_window_system
4547 #endif
4550 inregs.x.ax = 0x0021;
4551 int86 (0x33, &inregs, &outregs);
4552 have_mouse = (outregs.x.ax & 0xffff) == 0xffff;
4553 if (!have_mouse)
4555 /* Reportedly, the above doesn't work for some mouse drivers. There
4556 is an additional detection method that should work, but might be
4557 a little slower. Use that as an alternative. */
4558 inregs.x.ax = 0x0000;
4559 int86 (0x33, &inregs, &outregs);
4560 have_mouse = (outregs.x.ax & 0xffff) == 0xffff;
4563 if (have_mouse)
4565 have_mouse = 1; /* enable mouse */
4566 mouse_visible = 0;
4567 mouse_setup_buttons (outregs.x.bx);
4568 mouse_position_hook = &mouse_get_pos;
4569 mouse_init ();
4572 #ifndef HAVE_X_WINDOWS
4573 #if __DJGPP__ >= 2
4574 /* Save the cursor shape used outside Emacs. */
4575 outside_cursor = _farpeekw (_dos_ds, 0x460);
4576 #endif
4577 #endif
4580 first_time = 0;
4582 #if __DJGPP__ >= 2
4584 stdin_stat = setmode (fileno (stdin), O_BINARY);
4585 return (stdin_stat != -1);
4587 else
4588 return (setmode (fileno (stdin), O_BINARY) != -1);
4590 #else /* __DJGPP__ < 2 */
4594 /* I think it is wrong to overwrite `stdin_stat' every time
4595 but the first one this function is called, but I don't
4596 want to change the way it used to work in v1.x.--EZ */
4598 inregs.x.ax = 0x4400; /* Get IOCTL status. */
4599 inregs.x.bx = 0x00; /* 0 = stdin. */
4600 intdos (&inregs, &outregs);
4601 stdin_stat = outregs.h.dl;
4603 inregs.x.dx = stdin_stat | 0x0020; /* raw mode */
4604 inregs.x.ax = 0x4401; /* Set IOCTL status */
4605 intdos (&inregs, &outregs);
4606 return !outregs.x.cflag;
4608 #endif /* __DJGPP__ < 2 */
4611 /* Restore status of standard input and Ctrl-C checking. */
4614 dos_ttcooked ()
4616 union REGS inregs, outregs;
4618 setcbrk (break_stat);
4619 mouse_off ();
4621 #if __DJGPP__ >= 2
4623 #ifndef HAVE_X_WINDOWS
4624 /* Restore the cursor shape we found on startup. */
4625 if (outside_cursor)
4627 inregs.h.ah = 1;
4628 inregs.x.cx = outside_cursor;
4629 int86 (0x10, &inregs, &outregs);
4631 #endif
4633 return (setmode (fileno (stdin), stdin_stat) != -1);
4635 #else /* not __DJGPP__ >= 2 */
4637 inregs.x.ax = 0x4401; /* Set IOCTL status. */
4638 inregs.x.bx = 0x00; /* 0 = stdin. */
4639 inregs.x.dx = stdin_stat;
4640 intdos (&inregs, &outregs);
4641 return !outregs.x.cflag;
4643 #endif /* not __DJGPP__ >= 2 */
4647 /* Run command as specified by ARGV in directory DIR.
4648 The command is run with input from TEMPIN, output to
4649 file TEMPOUT and stderr to TEMPERR. */
4652 run_msdos_command (argv, working_dir, tempin, tempout, temperr, envv)
4653 unsigned char **argv;
4654 const char *working_dir;
4655 int tempin, tempout, temperr;
4656 char **envv;
4658 char *saveargv1, *saveargv2, *lowcase_argv0, *pa, *pl;
4659 char oldwd[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS. */
4660 int msshell, result = -1;
4661 int inbak, outbak, errbak;
4662 int x, y;
4663 Lisp_Object cmd;
4665 /* Get current directory as MSDOS cwd is not per-process. */
4666 getwd (oldwd);
4668 /* If argv[0] is the shell, it might come in any lettercase.
4669 Since `Fmember' is case-sensitive, we need to downcase
4670 argv[0], even if we are on case-preserving filesystems. */
4671 lowcase_argv0 = alloca (strlen (argv[0]) + 1);
4672 for (pa = argv[0], pl = lowcase_argv0; *pa; pl++)
4674 *pl = *pa++;
4675 if (*pl >= 'A' && *pl <= 'Z')
4676 *pl += 'a' - 'A';
4678 *pl = '\0';
4680 cmd = Ffile_name_nondirectory (build_string (lowcase_argv0));
4681 msshell = !NILP (Fmember (cmd, Fsymbol_value (intern ("msdos-shells"))))
4682 && !strcmp ("-c", argv[1]);
4683 if (msshell)
4685 saveargv1 = argv[1];
4686 saveargv2 = argv[2];
4687 argv[1] = "/c";
4688 /* We only need to mirror slashes if a DOS shell will be invoked
4689 not via `system' (which does the mirroring itself). Yes, that
4690 means DJGPP v1.x will lose here. */
4691 if (argv[2] && argv[3])
4693 char *p = alloca (strlen (argv[2]) + 1);
4695 strcpy (argv[2] = p, saveargv2);
4696 while (*p && isspace (*p))
4697 p++;
4698 while (*p)
4700 if (*p == '/')
4701 *p++ = '\\';
4702 else
4703 p++;
4708 chdir (working_dir);
4709 inbak = dup (0);
4710 outbak = dup (1);
4711 errbak = dup (2);
4712 if (inbak < 0 || outbak < 0 || errbak < 0)
4713 goto done; /* Allocation might fail due to lack of descriptors. */
4715 if (have_mouse > 0)
4716 mouse_get_xy (&x, &y);
4718 dos_ttcooked (); /* do it here while 0 = stdin */
4720 dup2 (tempin, 0);
4721 dup2 (tempout, 1);
4722 dup2 (temperr, 2);
4724 #if __DJGPP__ > 1
4726 if (msshell && !argv[3])
4728 /* MS-DOS native shells are too restrictive. For starters, they
4729 cannot grok commands longer than 126 characters. In DJGPP v2
4730 and later, `system' is much smarter, so we'll call it instead. */
4732 const char *cmnd;
4734 /* A shell gets a single argument--its full command
4735 line--whose original was saved in `saveargv2'. */
4737 /* Don't let them pass empty command lines to `system', since
4738 with some shells it will try to invoke an interactive shell,
4739 which will hang Emacs. */
4740 for (cmnd = saveargv2; *cmnd && isspace (*cmnd); cmnd++)
4742 if (*cmnd)
4744 extern char **environ;
4745 char **save_env = environ;
4746 int save_system_flags = __system_flags;
4748 /* Request the most powerful version of `system'. We need
4749 all the help we can get to avoid calling stock DOS shells. */
4750 __system_flags = (__system_redirect
4751 | __system_use_shell
4752 | __system_allow_multiple_cmds
4753 | __system_allow_long_cmds
4754 | __system_handle_null_commands
4755 | __system_emulate_chdir);
4757 environ = envv;
4758 result = system (cmnd);
4759 __system_flags = save_system_flags;
4760 environ = save_env;
4762 else
4763 result = 0; /* emulate Unixy shell behavior with empty cmd line */
4765 else
4767 #endif /* __DJGPP__ > 1 */
4769 result = spawnve (P_WAIT, argv[0], argv, envv);
4771 dup2 (inbak, 0);
4772 dup2 (outbak, 1);
4773 dup2 (errbak, 2);
4774 emacs_close (inbak);
4775 emacs_close (outbak);
4776 emacs_close (errbak);
4778 dos_ttraw ();
4779 if (have_mouse > 0)
4781 mouse_init ();
4782 mouse_moveto (x, y);
4785 /* Some programs might change the meaning of the highest bit of the
4786 text attribute byte, so we get blinking characters instead of the
4787 bright background colors. Restore that. */
4788 bright_bg ();
4790 done:
4791 chdir (oldwd);
4792 if (msshell)
4794 argv[1] = saveargv1;
4795 argv[2] = saveargv2;
4797 return result;
4800 croak (badfunc)
4801 char *badfunc;
4803 fprintf (stderr, "%s not yet implemented\r\n", badfunc);
4804 reset_sys_modes ();
4805 exit (1);
4808 #if __DJGPP__ < 2
4810 /* ------------------------- Compatibility functions -------------------
4811 * gethostname
4812 * gettimeofday
4815 /* Hostnames for a pc are not really funny,
4816 but they are used in change log so we emulate the best we can. */
4818 gethostname (p, size)
4819 char *p;
4820 int size;
4822 char *q = egetenv ("HOSTNAME");
4824 if (!q) q = "pc";
4825 strcpy (p, q);
4826 return 0;
4829 /* When time zones are set from Ms-Dos too many C-libraries are playing
4830 tricks with time values. We solve this by defining our own version
4831 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4832 once and after each call to `tzset' with TZ changed. That is
4833 accomplished by aliasing tzset to init_gettimeofday. */
4835 static struct tm time_rec;
4838 gettimeofday (struct timeval *tp, struct timezone *tzp)
4840 if (tp)
4842 struct time t;
4843 struct tm tm;
4845 gettime (&t);
4846 if (t.ti_hour < time_rec.tm_hour) /* midnight wrap */
4848 struct date d;
4849 getdate (&d);
4850 time_rec.tm_year = d.da_year - 1900;
4851 time_rec.tm_mon = d.da_mon - 1;
4852 time_rec.tm_mday = d.da_day;
4855 time_rec.tm_hour = t.ti_hour;
4856 time_rec.tm_min = t.ti_min;
4857 time_rec.tm_sec = t.ti_sec;
4859 tm = time_rec;
4860 tm.tm_gmtoff = dos_timezone_offset;
4862 tp->tv_sec = mktime (&tm); /* may modify tm */
4863 tp->tv_usec = t.ti_hund * (1000000 / 100);
4865 /* Ignore tzp; it's obsolescent. */
4866 return 0;
4869 #endif /* __DJGPP__ < 2 */
4872 * A list of unimplemented functions that we silently ignore.
4875 #if __DJGPP__ < 2
4876 unsigned alarm (s) unsigned s; {}
4877 fork () { return 0; }
4878 int kill (x, y) int x, y; { return -1; }
4879 nice (p) int p; {}
4880 void volatile pause () {}
4881 sigsetmask (x) int x; { return 0; }
4882 sigblock (mask) int mask; { return 0; }
4883 #endif
4885 void request_sigio (void) {}
4886 setpgrp () {return 0; }
4887 setpriority (x,y,z) int x,y,z; { return 0; }
4888 void unrequest_sigio (void) {}
4890 #if __DJGPP__ > 1
4892 #ifdef POSIX_SIGNALS
4894 /* Augment DJGPP library POSIX signal functions. This is needed
4895 as of DJGPP v2.01, but might be in the library in later releases. */
4897 #include <libc/bss.h>
4899 /* A counter to know when to re-initialize the static sets. */
4900 static int sigprocmask_count = -1;
4902 /* Which signals are currently blocked (initially none). */
4903 static sigset_t current_mask;
4905 /* Which signals are pending (initially none). */
4906 static sigset_t pending_signals;
4908 /* Previous handlers to restore when the blocked signals are unblocked. */
4909 typedef void (*sighandler_t)(int);
4910 static sighandler_t prev_handlers[320];
4912 /* A signal handler which just records that a signal occured
4913 (it will be raised later, if and when the signal is unblocked). */
4914 static void
4915 sig_suspender (signo)
4916 int signo;
4918 sigaddset (&pending_signals, signo);
4922 sigprocmask (how, new_set, old_set)
4923 int how;
4924 const sigset_t *new_set;
4925 sigset_t *old_set;
4927 int signo;
4928 sigset_t new_mask;
4930 /* If called for the first time, initialize. */
4931 if (sigprocmask_count != __bss_count)
4933 sigprocmask_count = __bss_count;
4934 sigemptyset (&pending_signals);
4935 sigemptyset (&current_mask);
4936 for (signo = 0; signo < 320; signo++)
4937 prev_handlers[signo] = SIG_ERR;
4940 if (old_set)
4941 *old_set = current_mask;
4943 if (new_set == 0)
4944 return 0;
4946 if (how != SIG_BLOCK && how != SIG_UNBLOCK && how != SIG_SETMASK)
4948 errno = EINVAL;
4949 return -1;
4952 sigemptyset (&new_mask);
4954 /* DJGPP supports upto 320 signals. */
4955 for (signo = 0; signo < 320; signo++)
4957 if (sigismember (&current_mask, signo))
4958 sigaddset (&new_mask, signo);
4959 else if (sigismember (new_set, signo) && how != SIG_UNBLOCK)
4961 sigaddset (&new_mask, signo);
4963 /* SIGKILL is silently ignored, as on other platforms. */
4964 if (signo != SIGKILL && prev_handlers[signo] == SIG_ERR)
4965 prev_handlers[signo] = signal (signo, sig_suspender);
4967 if (( how == SIG_UNBLOCK
4968 && sigismember (&new_mask, signo)
4969 && sigismember (new_set, signo))
4970 || (how == SIG_SETMASK
4971 && sigismember (&new_mask, signo)
4972 && !sigismember (new_set, signo)))
4974 sigdelset (&new_mask, signo);
4975 if (prev_handlers[signo] != SIG_ERR)
4977 signal (signo, prev_handlers[signo]);
4978 prev_handlers[signo] = SIG_ERR;
4980 if (sigismember (&pending_signals, signo))
4982 sigdelset (&pending_signals, signo);
4983 raise (signo);
4987 current_mask = new_mask;
4988 return 0;
4991 #else /* not POSIX_SIGNALS */
4993 sigsetmask (x) int x; { return 0; }
4994 sigblock (mask) int mask; { return 0; }
4996 #endif /* not POSIX_SIGNALS */
4997 #endif /* __DJGPP__ > 1 */
4999 #ifndef HAVE_SELECT
5000 #include "sysselect.h"
5002 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5003 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5004 ((long)(time).tv_sec < 0 \
5005 || ((time).tv_sec == 0 \
5006 && (long)(time).tv_usec <= 0))
5007 #endif
5009 /* This yields the rest of the current time slice to the task manager.
5010 It should be called by any code which knows that it has nothing
5011 useful to do except idle.
5013 I don't use __dpmi_yield here, since versions of library before 2.02
5014 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5015 on some versions of Windows 9X. */
5017 void
5018 dos_yield_time_slice (void)
5020 _go32_dpmi_registers r;
5022 r.x.ax = 0x1680;
5023 r.x.ss = r.x.sp = r.x.flags = 0;
5024 _go32_dpmi_simulate_int (0x2f, &r);
5025 if (r.h.al == 0x80)
5026 errno = ENOSYS;
5029 /* Only event queue is checked. */
5030 /* We don't have to call timer_check here
5031 because wait_reading_process_input takes care of that. */
5033 sys_select (nfds, rfds, wfds, efds, timeout)
5034 int nfds;
5035 SELECT_TYPE *rfds, *wfds, *efds;
5036 EMACS_TIME *timeout;
5038 int check_input;
5039 struct time t;
5041 check_input = 0;
5042 if (rfds)
5044 check_input = FD_ISSET (0, rfds);
5045 FD_ZERO (rfds);
5047 if (wfds)
5048 FD_ZERO (wfds);
5049 if (efds)
5050 FD_ZERO (efds);
5052 if (nfds != 1)
5053 abort ();
5055 /* If we are looking only for the terminal, with no timeout,
5056 just read it and wait -- that's more efficient. */
5057 if (!timeout)
5059 while (!detect_input_pending ())
5061 dos_yield_time_slice ();
5064 else
5066 EMACS_TIME clnow, cllast, cldiff;
5068 gettime (&t);
5069 EMACS_SET_SECS_USECS (cllast, t.ti_sec, t.ti_hund * 10000L);
5071 while (!check_input || !detect_input_pending ())
5073 gettime (&t);
5074 EMACS_SET_SECS_USECS (clnow, t.ti_sec, t.ti_hund * 10000L);
5075 EMACS_SUB_TIME (cldiff, clnow, cllast);
5077 /* When seconds wrap around, we assume that no more than
5078 1 minute passed since last `gettime'. */
5079 if (EMACS_TIME_NEG_P (cldiff))
5080 EMACS_SET_SECS (cldiff, EMACS_SECS (cldiff) + 60);
5081 EMACS_SUB_TIME (*timeout, *timeout, cldiff);
5083 /* Stop when timeout value crosses zero. */
5084 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout))
5085 return 0;
5086 cllast = clnow;
5087 dos_yield_time_slice ();
5091 FD_SET (0, rfds);
5092 return 1;
5094 #endif
5097 * Define overlaid functions:
5099 * chdir -> sys_chdir
5100 * tzset -> init_gettimeofday
5101 * abort -> dos_abort
5104 #ifdef chdir
5105 #undef chdir
5106 extern int chdir ();
5109 sys_chdir (path)
5110 const char* path;
5112 int len = strlen (path);
5113 char *tmp = (char *)path;
5115 if (*tmp && tmp[1] == ':')
5117 if (getdisk () != tolower (tmp[0]) - 'a')
5118 setdisk (tolower (tmp[0]) - 'a');
5119 tmp += 2; /* strip drive: KFS 1995-07-06 */
5120 len -= 2;
5123 if (len > 1 && (tmp[len - 1] == '/'))
5125 char *tmp1 = (char *) alloca (len + 1);
5126 strcpy (tmp1, tmp);
5127 tmp1[len - 1] = 0;
5128 tmp = tmp1;
5130 return chdir (tmp);
5132 #endif
5134 #ifdef tzset
5135 #undef tzset
5136 extern void tzset (void);
5138 void
5139 init_gettimeofday ()
5141 time_t ltm, gtm;
5142 struct tm *lstm;
5144 tzset ();
5145 ltm = gtm = time (NULL);
5146 ltm = mktime (lstm = localtime (&ltm));
5147 gtm = mktime (gmtime (&gtm));
5148 time_rec.tm_hour = 99; /* force gettimeofday to get date */
5149 time_rec.tm_isdst = lstm->tm_isdst;
5150 dos_timezone_offset = time_rec.tm_gmtoff = (int)(gtm - ltm) / 60;
5152 #endif
5154 #ifdef abort
5155 #undef abort
5156 void
5157 dos_abort (file, line)
5158 char *file;
5159 int line;
5161 char buffer1[200], buffer2[400];
5162 int i, j;
5164 sprintf (buffer1, "<EMACS FATAL ERROR IN %s LINE %d>", file, line);
5165 for (i = j = 0; buffer1[i]; i++) {
5166 buffer2[j++] = buffer1[i];
5167 buffer2[j++] = 0x70;
5169 dosmemput (buffer2, j, (int)ScreenPrimary);
5170 ScreenSetCursor (2, 0);
5171 abort ();
5173 #else
5174 void
5175 abort ()
5177 dos_ttcooked ();
5178 ScreenSetCursor (10, 0);
5179 cputs ("\r\n\nEmacs aborted!\r\n");
5180 #if __DJGPP__ > 1
5181 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5182 if (screen_virtual_segment)
5183 dosv_refresh_virtual_screen (2 * 10 * screen_size_X, 4 * screen_size_X);
5184 /* Generate traceback, so we could tell whodunit. */
5185 signal (SIGINT, SIG_DFL);
5186 __asm__ __volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5187 #else /* __DJGPP_MINOR__ >= 2 */
5188 raise (SIGABRT);
5189 #endif /* __DJGPP_MINOR__ >= 2 */
5190 #endif
5191 exit (2);
5193 #endif
5195 /* The following variables are required so that cus-start.el won't
5196 complain about unbound variables. */
5197 #ifndef HAVE_X_WINDOWS
5198 /* Search path for bitmap files (xfns.c). */
5199 Lisp_Object Vx_bitmap_file_path;
5200 int x_stretch_cursor_p;
5201 #endif
5202 #ifndef subprocesses
5203 /* Nonzero means delete a process right away if it exits (process.c). */
5204 static int delete_exited_processes;
5205 #endif
5207 syms_of_msdos ()
5209 recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
5210 staticpro (&recent_doskeys);
5211 #ifndef HAVE_X_WINDOWS
5212 help_echo = Qnil;
5213 staticpro (&help_echo);
5214 help_echo_object = Qnil;
5215 staticpro (&help_echo_object);
5216 help_echo_window = Qnil;
5217 staticpro (&help_echo_window);
5218 previous_help_echo = Qnil;
5219 staticpro (&previous_help_echo);
5220 help_echo_pos = -1;
5222 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
5223 "List of directories to search for bitmap files for X.");
5224 Vx_bitmap_file_path = decode_env_path ((char *) 0, ".");
5226 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
5227 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5228 For example, if a block cursor is over a tab, it will be drawn as\n\
5229 wide as that tab on the display. (No effect on MS-DOS.)");
5230 x_stretch_cursor_p = 0;
5232 /* The following three are from xfns.c: */
5233 Qbackground_color = intern ("background-color");
5234 staticpro (&Qbackground_color);
5235 Qforeground_color = intern ("foreground-color");
5236 staticpro (&Qforeground_color);
5237 Qbar = intern ("bar");
5238 staticpro (&Qbar);
5239 Qcursor_type = intern ("cursor-type");
5240 staticpro (&Qcursor_type);
5241 Qreverse = intern ("reverse");
5242 staticpro (&Qreverse);
5244 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph,
5245 "*Glyph to display instead of chars not supported by current codepage.\n\
5247 This variable is used only by MSDOS terminals.");
5248 Vdos_unsupported_char_glyph = '\177';
5249 #endif
5250 #ifndef subprocesses
5251 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
5252 "*Non-nil means delete processes immediately when they exit.\n\
5253 nil means don't delete them until `list-processes' is run.");
5254 delete_exited_processes = 0;
5255 #endif
5257 defsubr (&Srecent_doskeys);
5258 defsubr (&Smsdos_long_file_names);
5259 defsubr (&Smsdos_downcase_filename);
5260 defsubr (&Smsdos_remember_default_colors);
5261 defsubr (&Smsdos_set_mouse_buttons);
5264 #endif /* MSDOS */