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)
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. */
33 #include <sys/param.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. */
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 */
51 #include "termhooks.h"
53 #include "dispextern.h"
63 #include "blockinput.h"
68 /* #include <process.h> */
69 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
77 #define _dos_ds _go32_info_block.selector_for_linear_memory
83 #include "syssignal.h"
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. */
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 */
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
;
146 if (have_mouse
> 0 && !mouse_visible
)
149 fprintf (termscript
, "<M_ON>");
151 int86 (0x33, ®s
, ®s
);
161 if (have_mouse
> 0 && mouse_visible
)
164 fprintf (termscript
, "<M_OFF>");
166 int86 (0x33, ®s
, ®s
);
172 mouse_setup_buttons (int n_buttons
)
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.")
196 Lisp_Object nbuttons
;
198 CHECK_NUMBER (nbuttons
, 0);
199 mouse_setup_buttons (XINT (nbuttons
));
204 mouse_get_xy (int *x
, int *y
)
209 int86 (0x33, ®s
, ®s
);
221 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
223 mouse_last_x
= regs
.x
.cx
= x
* 8;
224 mouse_last_y
= regs
.x
.dx
= y
* 8;
225 int86 (0x33, ®s
, ®s
);
229 mouse_pressed (b
, xp
, yp
)
234 if (b
>= mouse_button_count
)
237 regs
.x
.bx
= mouse_button_translate
[b
];
238 int86 (0x33, ®s
, ®s
);
240 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
241 return (regs
.x
.bx
!= 0);
245 mouse_released (b
, xp
, yp
)
250 if (b
>= mouse_button_count
)
253 regs
.x
.bx
= mouse_button_translate
[b
];
254 int86 (0x33, ®s
, ®s
);
256 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
257 return (regs
.x
.bx
!= 0);
261 mouse_button_depressed (b
, xp
, yp
)
266 if (b
>= mouse_button_count
)
269 int86 (0x33, ®s
, ®s
);
270 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
280 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
283 Lisp_Object
*bar_window
, *x
, *y
;
284 enum scroll_bar_part
*part
;
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();
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
);
307 mouse_get_xy (&x
, &y
);
308 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
313 /* Force the mouse driver to ``forget'' about any button clicks until
316 mouse_clear_clicks (void)
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
);
335 fprintf (termscript
, "<M_INIT>");
338 int86 (0x33, ®s
, ®s
);
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 ();
348 regs
.x
.dx
= 8 * (ScreenCols () - 1);
349 int86 (0x33, ®s
, ®s
);
353 regs
.x
.dx
= 8 * (ScreenRows () - 1);
354 int86 (0x33, ®s
, ®s
);
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
;
410 /* Update the screen from a part of relocated DOS/V screen buffer which
411 begins at OFFSET and includes COUNT characters. */
413 dosv_refresh_virtual_screen (int offset
, int count
)
417 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
420 regs
.h
.ah
= 0xff; /* update relocated screen */
421 regs
.x
.es
= screen_virtual_segment
;
422 regs
.x
.di
= screen_virtual_offset
+ offset
;
424 __dpmi_int (0x10, ®s
);
429 dos_direct_output (y
, x
, buf
, len
)
435 int t0
= 2 * (x
+ y
* screen_size_X
);
436 int t
= t0
+ (int) ScreenPrimary
;
441 dosmemput (buf
++, 1, t
);
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
);
455 /* Flash the screen as a substitute for BEEPs. */
459 do_visible_bell (xorattr
)
460 unsigned char xorattr
;
465 movl _ScreenPrimary,%%eax
472 xorb %%al,%%gs:(%%ebx)
488 : "m" (xorattr
), "g" (screen_size
)
489 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
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
)
503 #ifndef HAVE_X_WINDOWS
505 static int blink_bit
= -1; /* the state of the blink bit at startup */
507 /* Enable bright background colors. */
513 /* Remember the original state of the blink/bright-background bit.
514 It is stored at 0040:0065h in the BIOS data area. */
516 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
520 int86 (0x10, ®s
, ®s
);
523 /* Disable bright background colors (and enable blinking) if we found
524 the video system in that state at startup. */
526 maybe_enable_blinking (void)
534 int86 (0x10, ®s
, ®s
);
538 /* Return non-zero if the system has a VGA adapter. */
545 int86 (0x10, ®s
, ®s
);
546 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
551 /* Set the screen dimensions so that it can show no less than
552 ROWS x COLS frame. */
555 dos_set_window_size (rows
, cols
)
559 Lisp_Object video_mode
;
560 int video_mode_value
;
563 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
565 if (*rows
== current_rows
&& *cols
== current_cols
)
569 have_vga
= vga_installed ();
571 /* If the user specified a special video mode for these dimensions,
573 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
574 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
577 if (INTEGERP (video_mode
)
578 && (video_mode_value
= XINT (video_mode
)) > 0)
580 regs
.x
.ax
= video_mode_value
;
581 int86 (0x10, ®s
, ®s
);
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... */
589 int86 (0x33, ®s
, ®s
);
593 /* Find one of the dimensions supported by standard EGA/VGA
594 which gives us at least the required dimensions. */
603 } std_dimension
[] = {
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
);
627 #else /* not __DJGPP__ > 1 */
629 else if (*rows
<= 25)
631 if (current_rows
!= 25 || current_cols
!= 80)
634 int86 (0x10, ®s
, ®s
);
637 int86 (0x10, ®s
, ®s
);
640 int86 (0x10, ®s
, ®s
);
642 int86 (0x10, ®s
, ®s
);
645 else if (*rows
<= 50)
646 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
647 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
650 int86 (0x10, ®s
, ®s
);
653 int86 (0x10, ®s
, ®s
);
656 int86 (0x10, ®s
, ®s
);
659 int86 (0x10, ®s
, ®s
);
661 #endif /* not __DJGPP__ > 1 */
669 /* Tell the caller what dimensions have been REALLY set. */
670 *rows
= ScreenRows ();
671 *cols
= ScreenCols ();
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
;
690 /* Enable bright background colors. */
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. */
710 mouse_get_xy (&x
, &y
);
711 if (y
!= new_pos_Y
|| x
< new_pos_X
)
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. */
725 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
728 unsigned desired_cursor
;
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
735 if (f
&& f
!= SELECTED_FRAME())
738 /* The character cell size in scan lines is stored at 40:85 in the
740 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
743 default: /* this relies on CGA cursor emulation being ON! */
760 if (width
== BOX_CURSOR_WIDTH
)
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
)
773 bot_line
= -1 - width
;
776 top_line
= bot_line
+ 1;
780 /* [31, 0] seems to DTRT for all screen sizes. */
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
793 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
794 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
798 regs
.x
.cx
= desired_cursor
;
799 __dpmi_int (0x10, ®s
);
800 #endif /* __DJGPP__ > 1 */
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
);
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,
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
);
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
);
851 union REGS inregs
, outregs
;
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
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
;
872 fp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
873 /* The default face for the frame should always be realized and
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
;
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;
915 if (bg
>= 0 && bg
< 16)
917 ScreenAttrib
&= 0x0f;
918 ScreenAttrib
|= ((bg
& 0x0f) << 4);
922 Lisp_Object Vdos_unsupported_char_glyph
;
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
941 : &safe_terminal_coding
);
944 /* Do we need to consider conversion of unibyte characters to
946 int convert_unibyte_characters
947 = (NILP (current_buffer
->enable_multibyte_characters
)
948 && unibyte_display_via_language_environment
);
950 if (str_len
<= 0) return;
952 screen_buf
= screen_bp
= alloca (str_len
* 2);
953 screen_buf_end
= screen_buf
+ str_len
* 2;
954 sf
= SELECTED_FRAME();
956 /* Since faces get cached and uncached behind our back, we can't
957 rely on their indices in the cache being consistent across
958 invocations. So always reset the screen face to the default
959 face of the frame, before writing glyphs, and let the glyphs
960 set the right face if it's different from the default. */
961 IT_set_face (DEFAULT_FACE_ID
);
963 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
965 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
968 int cf
, chlen
, enclen
;
969 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
972 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
973 only for the redisplay code to know how many columns does
974 this character occupy on the screen. Skip padding glyphs. */
975 if (CHAR_GLYPH_PADDING_P (*str
))
982 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
983 int glyph_not_in_table
= 0;
985 if (g
< 0 || g
>= tlen
)
987 /* This glyph doesn't have an entry in Vglyph_table. */
989 glyph_not_in_table
= 1;
993 /* This glyph has an entry in Vglyph_table, so process
994 any aliases before testing for simpleness. */
995 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
996 ch
= FAST_GLYPH_CHAR (g
);
999 /* Convert the character code to multibyte, if they
1000 requested display via language environment. We only want
1001 to convert unibyte characters to multibyte in unibyte
1002 buffers! Otherwise, the 8-bit value in CH came from the
1003 display table set up to display foreign characters. */
1004 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1006 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1007 ch
= unibyte_char_to_multibyte (ch
);
1009 /* Invalid characters are displayed with a special glyph. */
1010 if (! CHAR_VALID_P (ch
, 0))
1012 g
= !NILP (Vdos_unsupported_char_glyph
)
1013 ? Vdos_unsupported_char_glyph
1014 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1015 ch
= FAST_GLYPH_CHAR (g
);
1018 /* If the face of this glyph is different from the current
1019 screen face, update the screen attribute byte. */
1020 cf
= FAST_GLYPH_FACE (g
);
1021 if (cf
!= screen_face
)
1022 IT_set_face (cf
); /* handles invalid faces gracefully */
1024 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1026 /* We generate the multi-byte form of CH in WORKBUF. */
1027 chlen
= CHAR_STRING (ch
, workbuf
);
1032 /* We have a string in Vglyph_table. */
1033 chlen
= GLYPH_LENGTH (tbase
, g
);
1034 buf
= GLYPH_STRING (tbase
, g
);
1037 /* If the character is not multibyte, don't bother converting it. */
1040 *conversion_buffer
= (unsigned char)ch
;
1046 coding
->src_multibyte
= 1;
1047 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1048 conversion_buffer_size
);
1049 chlen
-= coding
->consumed
;
1050 enclen
= coding
->produced
;
1052 /* Replace glyph codes that cannot be converted by
1053 terminal_coding with Vdos_unsupported_char_glyph. */
1054 if (*conversion_buffer
== '?')
1056 char *cbp
= conversion_buffer
;
1058 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1059 *cbp
++ = unsupported_char
;
1060 if (unsupported_face
!= screen_face
)
1061 IT_set_face (unsupported_face
);
1065 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1067 /* The allocated buffer for screen writes is too small.
1068 Flush it and loop again without incrementing STR, so
1069 that the next loop will begin with the same glyph. */
1070 int nbytes
= screen_bp
- screen_buf
;
1073 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1074 if (screen_virtual_segment
)
1075 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1076 new_pos_X
+= nbytes
/ 2;
1079 /* Prepare to reuse the same buffer again. */
1080 screen_bp
= screen_buf
;
1084 /* There's enough place in the allocated buffer to add
1085 the encoding of this glyph. */
1087 /* First, copy the encoded bytes. */
1088 for (bp
= conversion_buffer
; enclen
--; bp
++)
1090 *screen_bp
++ = (unsigned char)*bp
;
1091 *screen_bp
++ = ScreenAttrib
;
1093 fputc (*bp
, termscript
);
1096 /* Now copy the bytes not consumed by the encoding. */
1099 buf
+= coding
->consumed
;
1103 fputc (*buf
, termscript
);
1104 *screen_bp
++ = (unsigned char)*buf
++;
1105 *screen_bp
++ = ScreenAttrib
;
1109 /* Update STR and its remaining length. */
1116 /* Dump whatever is left in the screen buffer. */
1118 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1119 if (screen_virtual_segment
)
1120 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1121 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1123 /* We may have to output some codes to terminate the writing. */
1124 if (CODING_REQUIRE_FLUSHING (coding
))
1126 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1127 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1128 if (coding
->produced
> 0)
1130 screen_buf
= alloca (coding
->produced
* 2);
1131 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1132 coding
->produced
--; bp
++)
1134 *screen_bp
++ = (unsigned char)*bp
;
1135 *screen_bp
++ = ScreenAttrib
;
1137 fputc (*bp
, termscript
);
1139 offset
+= screen_bp
- screen_buf
;
1141 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1142 (int)ScreenPrimary
+ offset
);
1143 if (screen_virtual_segment
)
1144 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1145 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1150 /************************************************************************
1151 Mouse Highlight (and friends..)
1152 ************************************************************************/
1154 /* This is used for debugging, to turn off note_mouse_highlight. */
1155 int disable_mouse_highlight
;
1157 /* If non-nil, dos_rawgetc generates an event to display that string.
1158 (The display is done in keyboard.c:read_char, by calling
1160 static Lisp_Object help_echo
;
1161 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1163 /* These record the window, the object and the position where the help
1164 echo string was generated. */
1165 static Lisp_Object help_echo_window
;
1166 static Lisp_Object help_echo_object
;
1167 static int help_echo_pos
;
1169 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1171 /* Set the mouse pointer shape according to whether it is in the
1172 area where the mouse highlight is in effect. */
1174 IT_set_mouse_pointer (int mode
)
1176 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1177 many possibilities to change its shape, and the available
1178 functionality pretty much sucks (e.g., almost every reasonable
1179 shape will conceal the character it is on). Since the color of
1180 the pointer changes in the highlighted area, it is not clear to
1181 me whether anything else is required, anyway. */
1184 /* Display the active region described by mouse_face_*
1185 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1187 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1189 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1190 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1195 /* If window is in the process of being destroyed, don't bother
1197 if (w
->current_matrix
== NULL
)
1198 goto set_cursor_shape
;
1200 /* Recognize when we are called to operate on rows that don't exist
1201 anymore. This can happen when a window is split. */
1202 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1203 goto set_cursor_shape
;
1205 /* There's no sense to do anything if the mouse face isn't realized. */
1208 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1210 goto set_cursor_shape
;
1213 /* Note that mouse_face_beg_row etc. are window relative. */
1214 for (i
= dpyinfo
->mouse_face_beg_row
;
1215 i
<= dpyinfo
->mouse_face_end_row
;
1218 int start_hpos
, end_hpos
;
1219 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1221 /* Don't do anything if row doesn't have valid contents. */
1222 if (!row
->enabled_p
)
1225 /* For all but the first row, the highlight starts at column 0. */
1226 if (i
== dpyinfo
->mouse_face_beg_row
)
1227 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1231 if (i
== dpyinfo
->mouse_face_end_row
)
1232 end_hpos
= dpyinfo
->mouse_face_end_col
;
1234 end_hpos
= row
->used
[TEXT_AREA
];
1236 if (end_hpos
<= start_hpos
)
1238 /* Record that some glyphs of this row are displayed in
1240 row
->mouse_face_p
= hl
> 0;
1243 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1244 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1245 int nglyphs
= end_hpos
- start_hpos
;
1246 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1247 int start_offset
= offset
;
1250 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1251 kstart
, kstart
+ nglyphs
- 1, vpos
);
1254 IT_set_face (dpyinfo
->mouse_face_face_id
);
1255 /* Since we are going to change only the _colors_ of the
1256 displayed text, there's no need to go through all the
1257 pain of generating and encoding the text from the glyphs.
1258 Instead, we simply poke the attribute byte of each
1259 affected position in video memory with the colors
1260 computed by IT_set_face! */
1261 _farsetsel (_dos_ds
);
1264 _farnspokeb (offset
, ScreenAttrib
);
1267 if (screen_virtual_segment
)
1268 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1273 /* We are removing a previously-drawn mouse highlight. The
1274 safest way to do so is to redraw the glyphs anew, since
1275 all kinds of faces and display tables could have changed
1277 int nglyphs
= end_hpos
- start_hpos
;
1278 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1280 if (end_hpos
>= row
->used
[TEXT_AREA
])
1281 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1283 /* IT_write_glyphs writes at cursor position, so we need to
1284 temporarily move cursor coordinates to the beginning of
1285 the highlight region. */
1286 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1287 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1290 fprintf (termscript
, "<MH- %d-%d:%d>",
1291 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1292 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1294 fputs ("\n", termscript
);
1302 /* Change the mouse pointer shape. */
1303 IT_set_mouse_pointer (hl
);
1306 /* Clear out the mouse-highlighted active region.
1307 Redraw it un-highlighted first. */
1309 clear_mouse_face (struct display_info
*dpyinfo
)
1311 if (! NILP (dpyinfo
->mouse_face_window
))
1312 show_mouse_face (dpyinfo
, 0);
1314 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1315 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1316 dpyinfo
->mouse_face_window
= Qnil
;
1319 /* Find the glyph matrix position of buffer position POS in window W.
1320 *HPOS and *VPOS are set to the positions found. W's current glyphs
1321 must be up to date. If POS is above window start return (0, 0).
1322 If POS is after end of W, return end of last line in W. */
1324 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1328 int maybe_next_line_p
= 0;
1329 int line_start_position
;
1330 int yb
= window_text_bottom_y (w
);
1331 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1332 struct glyph_row
*best_row
= row
;
1336 if (row
->used
[TEXT_AREA
])
1337 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1339 line_start_position
= 0;
1341 if (line_start_position
> pos
)
1343 /* If the position sought is the end of the buffer,
1344 don't include the blank lines at the bottom of the window. */
1345 else if (line_start_position
== pos
1346 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1348 maybe_next_line_p
= 1;
1351 else if (line_start_position
> 0)
1357 /* Find the right column within BEST_ROW. */
1360 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1362 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1365 charpos
= glyph
->charpos
;
1372 else if (charpos
> pos
)
1374 else if (charpos
> 0)
1378 /* If we're looking for the end of the buffer,
1379 and we didn't find it in the line we scanned,
1380 use the start of the following line. */
1381 if (maybe_next_line_p
)
1388 *hpos
= lastcol
+ 1;
1392 /* Take proper action when mouse has moved to the mode or top line of
1393 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1394 mode line. X is relative to the start of the text display area of
1395 W, so the width of bitmap areas and scroll bars must be subtracted
1396 to get a position relative to the start of the mode line. */
1398 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1400 struct frame
*f
= XFRAME (w
->frame
);
1401 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1402 struct glyph_row
*row
;
1405 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1407 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1411 extern Lisp_Object Qhelp_echo
;
1412 struct glyph
*glyph
, *end
;
1413 Lisp_Object help
, map
;
1415 /* Find the glyph under X. */
1416 glyph
= row
->glyphs
[TEXT_AREA
]
1417 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1418 end
= glyph
+ row
->used
[TEXT_AREA
];
1420 && STRINGP (glyph
->object
)
1421 && XSTRING (glyph
->object
)->intervals
1422 && glyph
->charpos
>= 0
1423 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1425 /* If we're on a string with `help-echo' text property,
1426 arrange for the help to be displayed. This is done by
1427 setting the global variable help_echo to the help string. */
1428 help
= Fget_text_property (make_number (glyph
->charpos
),
1429 Qhelp_echo
, glyph
->object
);
1433 XSETWINDOW (help_echo_window
, w
);
1434 help_echo_object
= glyph
->object
;
1435 help_echo_pos
= glyph
->charpos
;
1441 /* Take proper action when the mouse has moved to position X, Y on
1442 frame F as regards highlighting characters that have mouse-face
1443 properties. Also de-highlighting chars where the mouse was before.
1444 X and Y can be negative or out of range. */
1446 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1448 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1453 /* When a menu is active, don't highlight because this looks odd. */
1454 if (mouse_preempted
)
1457 if (disable_mouse_highlight
1458 || !f
->glyphs_initialized_p
)
1461 dpyinfo
->mouse_face_mouse_x
= x
;
1462 dpyinfo
->mouse_face_mouse_y
= y
;
1463 dpyinfo
->mouse_face_mouse_frame
= f
;
1465 if (dpyinfo
->mouse_face_defer
)
1470 dpyinfo
->mouse_face_deferred_gc
= 1;
1474 /* Which window is that in? */
1475 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1477 /* If we were displaying active text in another window, clear that. */
1478 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1479 clear_mouse_face (dpyinfo
);
1481 /* Not on a window -> return. */
1482 if (!WINDOWP (window
))
1485 /* Convert to window-relative coordinates. */
1486 w
= XWINDOW (window
);
1487 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1488 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1490 if (portion
== 1 || portion
== 3)
1492 /* Mouse is on the mode or top line. */
1493 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1497 IT_set_mouse_pointer (0);
1499 /* Are we in a window whose display is up to date?
1500 And verify the buffer's text has not changed. */
1501 if (/* Within text portion of the window. */
1503 && EQ (w
->window_end_valid
, w
->buffer
)
1504 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1505 && (XFASTINT (w
->last_overlay_modified
)
1506 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1509 struct glyph_row
*row
;
1510 struct glyph
*glyph
;
1512 /* Find the glyph under X/Y. */
1514 if (y
< w
->current_matrix
->nrows
)
1516 row
= MATRIX_ROW (w
->current_matrix
, y
);
1518 && row
->displays_text_p
1519 && x
< window_box_width (w
, TEXT_AREA
))
1521 glyph
= row
->glyphs
[TEXT_AREA
];
1522 if (x
>= row
->used
[TEXT_AREA
])
1527 if (!BUFFERP (glyph
->object
))
1533 /* Clear mouse face if X/Y not over text. */
1536 clear_mouse_face (dpyinfo
);
1540 if (!BUFFERP (glyph
->object
))
1542 pos
= glyph
->charpos
;
1544 /* Check for mouse-face and help-echo. */
1546 extern Lisp_Object Qmouse_face
;
1547 Lisp_Object mouse_face
, overlay
, position
;
1548 Lisp_Object
*overlay_vec
;
1550 struct buffer
*obuf
;
1553 /* If we get an out-of-range value, return now; avoid an error. */
1554 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1557 /* Make the window's buffer temporarily current for
1558 overlays_at and compute_char_face. */
1559 obuf
= current_buffer
;
1560 current_buffer
= XBUFFER (w
->buffer
);
1566 /* Is this char mouse-active or does it have help-echo? */
1567 XSETINT (position
, pos
);
1569 /* Put all the overlays we want in a vector in overlay_vec.
1570 Store the length in len. If there are more than 10, make
1571 enough space for all, and try again. */
1573 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1574 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1575 if (noverlays
> len
)
1578 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1579 noverlays
= overlays_at (pos
,
1580 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1583 /* Sort overlays into increasing priority order. */
1584 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1586 /* Check mouse-face highlighting. */
1587 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1588 && y
>= dpyinfo
->mouse_face_beg_row
1589 && y
<= dpyinfo
->mouse_face_end_row
1590 && (y
> dpyinfo
->mouse_face_beg_row
1591 || x
>= dpyinfo
->mouse_face_beg_col
)
1592 && (y
< dpyinfo
->mouse_face_end_row
1593 || x
< dpyinfo
->mouse_face_end_col
1594 || dpyinfo
->mouse_face_past_end
)))
1596 /* Clear the display of the old active region, if any. */
1597 clear_mouse_face (dpyinfo
);
1599 /* Find highest priority overlay that has a mouse-face prop. */
1601 for (i
= noverlays
- 1; i
>= 0; --i
)
1603 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1604 if (!NILP (mouse_face
))
1606 overlay
= overlay_vec
[i
];
1611 /* If no overlay applies, get a text property. */
1613 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1616 /* Handle the overlay case. */
1617 if (! NILP (overlay
))
1619 /* Find the range of text around this char that
1620 should be active. */
1621 Lisp_Object before
, after
;
1624 before
= Foverlay_start (overlay
);
1625 after
= Foverlay_end (overlay
);
1626 /* Record this as the current active region. */
1627 fast_find_position (w
, XFASTINT (before
),
1628 &dpyinfo
->mouse_face_beg_col
,
1629 &dpyinfo
->mouse_face_beg_row
);
1630 dpyinfo
->mouse_face_past_end
1631 = !fast_find_position (w
, XFASTINT (after
),
1632 &dpyinfo
->mouse_face_end_col
,
1633 &dpyinfo
->mouse_face_end_row
);
1634 dpyinfo
->mouse_face_window
= window
;
1635 dpyinfo
->mouse_face_face_id
1636 = face_at_buffer_position (w
, pos
, 0, 0,
1637 &ignore
, pos
+ 1, 1);
1639 /* Display it as active. */
1640 show_mouse_face (dpyinfo
, 1);
1642 /* Handle the text property case. */
1643 else if (! NILP (mouse_face
))
1645 /* Find the range of text around this char that
1646 should be active. */
1647 Lisp_Object before
, after
, beginning
, end
;
1650 beginning
= Fmarker_position (w
->start
);
1651 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1652 - XFASTINT (w
->window_end_pos
)));
1654 = Fprevious_single_property_change (make_number (pos
+ 1),
1656 w
->buffer
, beginning
);
1658 = Fnext_single_property_change (position
, Qmouse_face
,
1660 /* Record this as the current active region. */
1661 fast_find_position (w
, XFASTINT (before
),
1662 &dpyinfo
->mouse_face_beg_col
,
1663 &dpyinfo
->mouse_face_beg_row
);
1664 dpyinfo
->mouse_face_past_end
1665 = !fast_find_position (w
, XFASTINT (after
),
1666 &dpyinfo
->mouse_face_end_col
,
1667 &dpyinfo
->mouse_face_end_row
);
1668 dpyinfo
->mouse_face_window
= window
;
1669 dpyinfo
->mouse_face_face_id
1670 = face_at_buffer_position (w
, pos
, 0, 0,
1671 &ignore
, pos
+ 1, 1);
1673 /* Display it as active. */
1674 show_mouse_face (dpyinfo
, 1);
1678 /* Look for a `help-echo' property. */
1681 extern Lisp_Object Qhelp_echo
;
1683 /* Check overlays first. */
1685 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1687 overlay
= overlay_vec
[i
];
1688 help
= Foverlay_get (overlay
, Qhelp_echo
);
1694 help_echo_window
= window
;
1695 help_echo_object
= overlay
;
1696 help_echo_pos
= pos
;
1698 /* Try text properties. */
1699 else if (NILP (help
)
1700 && ((STRINGP (glyph
->object
)
1701 && glyph
->charpos
>= 0
1702 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1703 || (BUFFERP (glyph
->object
)
1704 && glyph
->charpos
>= BEGV
1705 && glyph
->charpos
< ZV
)))
1707 help
= Fget_text_property (make_number (glyph
->charpos
),
1708 Qhelp_echo
, glyph
->object
);
1712 help_echo_window
= window
;
1713 help_echo_object
= glyph
->object
;
1714 help_echo_pos
= glyph
->charpos
;
1721 current_buffer
= obuf
;
1727 IT_clear_end_of_line (int first_unused
)
1731 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1732 extern int fatal_error_in_progress
;
1734 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1738 i
= (j
= first_unused
- new_pos_X
) * 2;
1740 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1741 spaces
= sp
= alloca (i
);
1746 *sp
++ = ScreenAttrib
;
1750 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1751 if (screen_virtual_segment
)
1752 dosv_refresh_virtual_screen (offset
, i
/ 2);
1754 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1755 Let's follow their lead, in case someone relies on this. */
1756 new_pos_X
= first_unused
;
1760 IT_clear_screen (void)
1763 fprintf (termscript
, "<CLR:SCR>");
1767 if (screen_virtual_segment
)
1768 dosv_refresh_virtual_screen (0, screen_size
);
1769 new_pos_X
= new_pos_Y
= 0;
1773 IT_clear_to_end (void)
1776 fprintf (termscript
, "<CLR:EOS>");
1778 while (new_pos_Y
< screen_size_Y
) {
1780 IT_clear_end_of_line (screen_size_X
);
1786 IT_cursor_to (int y
, int x
)
1789 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1794 static int cursor_cleared
;
1797 IT_display_cursor (int on
)
1799 if (on
&& cursor_cleared
)
1801 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1804 else if (!on
&& !cursor_cleared
)
1806 ScreenSetCursor (-1, -1);
1811 /* Emacs calls cursor-movement functions a lot when it updates the
1812 display (probably a legacy of old terminals where you cannot
1813 update a screen line without first moving the cursor there).
1814 However, cursor movement is expensive on MSDOS (it calls a slow
1815 BIOS function and requires 2 mode switches), while actual screen
1816 updates access the video memory directly and don't depend on
1817 cursor position. To avoid slowing down the redisplay, we cheat:
1818 all functions that move the cursor only set internal variables
1819 which record the cursor position, whereas the cursor is only
1820 moved to its final position whenever screen update is complete.
1822 `IT_cmgoto' is called from the keyboard reading loop and when the
1823 frame update is complete. This means that we are ready for user
1824 input, so we update the cursor position to show where the point is,
1825 and also make the mouse pointer visible.
1827 Special treatment is required when the cursor is in the echo area,
1828 to put the cursor at the end of the text displayed there. */
1831 IT_cmgoto (FRAME_PTR f
)
1833 /* Only set the cursor to where it should be if the display is
1834 already in sync with the window contents. */
1835 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1837 /* FIXME: This needs to be rewritten for the new redisplay, or
1840 static int previous_pos_X
= -1;
1842 update_cursor_pos
= 1; /* temporary!!! */
1844 /* If the display is in sync, forget any previous knowledge about
1845 cursor position. This is primarily for unexpected events like
1846 C-g in the minibuffer. */
1847 if (update_cursor_pos
&& previous_pos_X
>= 0)
1848 previous_pos_X
= -1;
1849 /* If we are in the echo area, put the cursor at the
1850 end of the echo area message. */
1851 if (!update_cursor_pos
1852 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1854 int tem_X
= current_pos_X
, dummy
;
1856 if (echo_area_glyphs
)
1858 tem_X
= echo_area_glyphs_length
;
1859 /* Save current cursor position, to be restored after the
1860 echo area message is erased. Only remember one level
1861 of previous cursor position. */
1862 if (previous_pos_X
== -1)
1863 ScreenGetCursor (&dummy
, &previous_pos_X
);
1865 else if (previous_pos_X
>= 0)
1867 /* We wind up here after the echo area message is erased.
1868 Restore the cursor position we remembered above. */
1869 tem_X
= previous_pos_X
;
1870 previous_pos_X
= -1;
1873 if (current_pos_X
!= tem_X
)
1876 update_cursor_pos
= 1;
1881 if (update_cursor_pos
1882 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1884 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1886 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1889 /* Maybe cursor is invisible, so make it visible. */
1890 IT_display_cursor (1);
1892 /* Mouse pointer should be always visible if we are waiting for
1899 IT_reassert_line_highlight (int new, int vpos
)
1905 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1907 highlight
= new_highlight
;
1908 IT_cursor_to (vpos
, 0);
1909 IT_clear_end_of_line (first_unused_hpos
);
1913 IT_update_begin (struct frame
*f
)
1915 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1921 if (f
== display_info
->mouse_face_mouse_frame
)
1923 /* Don't do highlighting for mouse motion during the update. */
1924 display_info
->mouse_face_defer
= 1;
1926 /* If F needs to be redrawn, simply forget about any prior mouse
1928 if (FRAME_GARBAGED_P (f
))
1929 display_info
->mouse_face_window
= Qnil
;
1931 /* Can we tell that this update does not affect the window
1932 where the mouse highlight is? If so, no need to turn off.
1933 Likewise, don't do anything if none of the enabled rows
1934 contains glyphs highlighted in mouse face. */
1935 if (!NILP (display_info
->mouse_face_window
)
1936 && WINDOWP (display_info
->mouse_face_window
))
1938 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1941 /* If the mouse highlight is in the window that was deleted
1942 (e.g., if it was popped by completion), clear highlight
1944 if (NILP (w
->buffer
))
1945 display_info
->mouse_face_window
= Qnil
;
1948 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1949 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1950 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1954 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1955 clear_mouse_face (display_info
);
1958 else if (!FRAME_LIVE_P (display_info
->mouse_face_mouse_frame
))
1960 /* If the frame with mouse highlight was deleted, invalidate the
1962 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1963 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1964 display_info
->mouse_face_window
= Qnil
;
1965 display_info
->mouse_face_deferred_gc
= 0;
1966 display_info
->mouse_face_mouse_frame
= NULL
;
1973 IT_update_end (struct frame
*f
)
1976 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1979 Lisp_Object Qcursor_type
;
1982 IT_frame_up_to_date (struct frame
*f
)
1984 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1985 Lisp_Object new_cursor
, frame_desired_cursor
;
1988 if (dpyinfo
->mouse_face_deferred_gc
1989 || f
== dpyinfo
->mouse_face_mouse_frame
)
1992 if (dpyinfo
->mouse_face_mouse_frame
)
1993 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1994 dpyinfo
->mouse_face_mouse_x
,
1995 dpyinfo
->mouse_face_mouse_y
);
1996 dpyinfo
->mouse_face_deferred_gc
= 0;
2000 /* Set the cursor type to whatever they wanted. In a minibuffer
2001 window, we want the cursor to appear only if we are reading input
2002 from this window, and we want the cursor to be taken from the
2003 frame parameters. For the selected window, we use either its
2004 buffer-local value or the value from the frame parameters if the
2005 buffer doesn't define its local value for the cursor type. */
2006 sw
= XWINDOW (f
->selected_window
);
2007 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2008 if (cursor_in_echo_area
2009 && FRAME_HAS_MINIBUF_P (f
)
2010 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2011 && sw
== XWINDOW (echo_area_window
))
2012 new_cursor
= frame_desired_cursor
;
2015 struct buffer
*b
= XBUFFER (sw
->buffer
);
2017 if (EQ (b
->cursor_type
, Qt
))
2018 new_cursor
= frame_desired_cursor
;
2019 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2020 new_cursor
= Fcons (Qbar
, make_number (0));
2022 new_cursor
= b
->cursor_type
;
2025 IT_set_cursor_type (f
, new_cursor
);
2027 IT_cmgoto (f
); /* position cursor when update is done */
2030 /* Copy LEN glyphs displayed on a single line whose vertical position
2031 is YPOS, beginning at horizontal position XFROM to horizontal
2032 position XTO, by moving blocks in the video memory. Used by
2033 functions that insert and delete glyphs. */
2035 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2037 /* The offsets of source and destination relative to the
2038 conventional memorty selector. */
2039 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2040 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2042 if (from
== to
|| len
<= 0)
2045 _farsetsel (_dos_ds
);
2047 /* The source and destination might overlap, so we need to move
2048 glyphs non-destructively. */
2051 for ( ; len
; from
+= 2, to
+= 2, len
--)
2052 _farnspokew (to
, _farnspeekw (from
));
2056 from
+= (len
- 1) * 2;
2057 to
+= (len
- 1) * 2;
2058 for ( ; len
; from
-= 2, to
-= 2, len
--)
2059 _farnspokew (to
, _farnspeekw (from
));
2061 if (screen_virtual_segment
)
2062 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2065 /* Insert and delete glyphs. */
2067 IT_insert_glyphs (start
, len
)
2068 register struct glyph
*start
;
2071 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2073 /* Shift right the glyphs from the nominal cursor position to the
2074 end of this line. */
2075 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2077 /* Now write the glyphs to be inserted. */
2078 IT_write_glyphs (start
, len
);
2082 IT_delete_glyphs (n
)
2088 /* set-window-configuration on window.c needs this. */
2090 x_set_menu_bar_lines (f
, value
, oldval
)
2092 Lisp_Object value
, oldval
;
2094 set_menu_bar_lines (f
, value
, oldval
);
2097 /* This was copied from xfns.c */
2099 Lisp_Object Qbackground_color
;
2100 Lisp_Object Qforeground_color
;
2101 Lisp_Object Qreverse
;
2102 extern Lisp_Object Qtitle
;
2104 /* IT_set_terminal_modes is called when emacs is started,
2105 resumed, and whenever the screen is redrawn! */
2108 IT_set_terminal_modes (void)
2111 fprintf (termscript
, "\n<SET_TERM>");
2114 screen_size_X
= ScreenCols ();
2115 screen_size_Y
= ScreenRows ();
2116 screen_size
= screen_size_X
* screen_size_Y
;
2118 new_pos_X
= new_pos_Y
= 0;
2119 current_pos_X
= current_pos_Y
= -1;
2121 if (term_setup_done
)
2123 term_setup_done
= 1;
2125 startup_screen_size_X
= screen_size_X
;
2126 startup_screen_size_Y
= screen_size_Y
;
2127 startup_screen_attrib
= ScreenAttrib
;
2130 /* Is DOS/V (or any other RSIS software which relocates
2131 the screen) installed? */
2133 unsigned short es_value
;
2136 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2137 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2138 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2139 else if (screen_old_address
) /* already switched to Japanese mode once */
2140 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2142 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2144 es_value
= regs
.x
.es
;
2145 __dpmi_int (0x10, ®s
);
2147 if (regs
.x
.es
!= es_value
)
2149 /* screen_old_address is only set if ScreenPrimary does NOT
2150 already point to the relocated buffer address returned by
2151 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2152 ScreenPrimary to that address at startup under DOS/V. */
2153 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2154 screen_old_address
= ScreenPrimary
;
2155 screen_virtual_segment
= regs
.x
.es
;
2156 screen_virtual_offset
= regs
.x
.di
;
2157 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2160 #endif /* __DJGPP__ > 1 */
2162 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2163 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2166 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2167 screen_size_X
, screen_size_Y
);
2172 /* IT_reset_terminal_modes is called when emacs is
2173 suspended or killed. */
2176 IT_reset_terminal_modes (void)
2178 int display_row_start
= (int) ScreenPrimary
;
2179 int saved_row_len
= startup_screen_size_X
* 2;
2180 int update_row_len
= ScreenCols () * 2;
2181 int current_rows
= ScreenRows ();
2182 int to_next_row
= update_row_len
;
2183 unsigned char *saved_row
= startup_screen_buffer
;
2184 int cursor_pos_X
= ScreenCols () - 1;
2185 int cursor_pos_Y
= ScreenRows () - 1;
2188 fprintf (termscript
, "\n<RESET_TERM>");
2192 if (!term_setup_done
)
2197 /* Leave the video system in the same state as we found it,
2198 as far as the blink/bright-background bit is concerned. */
2199 maybe_enable_blinking ();
2201 /* We have a situation here.
2202 We cannot just do ScreenUpdate(startup_screen_buffer) because
2203 the luser could have changed screen dimensions inside Emacs
2204 and failed (or didn't want) to restore them before killing
2205 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2206 thus will happily use memory outside what was allocated for
2207 `startup_screen_buffer'.
2208 Thus we only restore as much as the current screen dimensions
2209 can hold, and clear the rest (if the saved screen is smaller than
2210 the current) with the color attribute saved at startup. The cursor
2211 is also restored within the visible dimensions. */
2213 ScreenAttrib
= startup_screen_attrib
;
2215 /* Don't restore the screen if we are exiting less than 2 seconds
2216 after startup: we might be crashing, and the screen might show
2217 some vital clues to what's wrong. */
2218 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2221 if (screen_virtual_segment
)
2222 dosv_refresh_virtual_screen (0, screen_size
);
2224 if (update_row_len
> saved_row_len
)
2225 update_row_len
= saved_row_len
;
2226 if (current_rows
> startup_screen_size_Y
)
2227 current_rows
= startup_screen_size_Y
;
2230 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2231 update_row_len
/ 2, current_rows
);
2233 while (current_rows
--)
2235 dosmemput (saved_row
, update_row_len
, display_row_start
);
2236 if (screen_virtual_segment
)
2237 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2238 update_row_len
/ 2);
2239 saved_row
+= saved_row_len
;
2240 display_row_start
+= to_next_row
;
2243 if (startup_pos_X
< cursor_pos_X
)
2244 cursor_pos_X
= startup_pos_X
;
2245 if (startup_pos_Y
< cursor_pos_Y
)
2246 cursor_pos_Y
= startup_pos_Y
;
2248 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2249 xfree (startup_screen_buffer
);
2251 term_setup_done
= 0;
2255 IT_set_terminal_window (int foo
)
2259 /* Remember the screen colors of the curent frame, to serve as the
2260 default colors for newly-created frames. */
2262 static int initial_screen_colors
[2];
2264 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2265 Smsdos_remember_default_colors
, 1, 1, 0,
2266 "Remember the screen colors of the current frame.")
2273 CHECK_FRAME (frame
, 0);
2275 reverse
= EQ (Fcdr (Fassq (intern ("reverse"), f
->param_alist
)), Qt
);
2277 initial_screen_colors
[0]
2278 = reverse
? FRAME_BACKGROUND_PIXEL (f
) : FRAME_FOREGROUND_PIXEL (f
);
2279 initial_screen_colors
[1]
2280 = reverse
? FRAME_FOREGROUND_PIXEL (f
) : FRAME_BACKGROUND_PIXEL (f
);
2284 IT_set_frame_parameters (f
, alist
)
2289 int length
= XINT (Flength (alist
));
2292 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2294 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2295 /* Do we have to reverse the foreground and background colors? */
2296 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2297 int was_reverse
= reverse
;
2298 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2299 unsigned long orig_fg
;
2300 unsigned long orig_bg
;
2302 /* If we are creating a new frame, begin with the original screen colors
2303 used for the initial frame. */
2304 if (alist
== Vdefault_frame_alist
2305 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2307 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2308 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2310 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2311 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2313 /* Extract parm names and values into those vectors. */
2315 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2320 parms
[i
] = Fcar (elt
);
2321 CHECK_SYMBOL (parms
[i
], 1);
2322 values
[i
] = Fcdr (elt
);
2328 for (i
= 0; i
< j
; i
++)
2330 Lisp_Object prop
= parms
[i
];
2331 Lisp_Object val
= values
[i
];
2333 if (EQ (prop
, Qreverse
))
2334 reverse
= EQ (val
, Qt
);
2337 if (termscript
&& reverse
&& !was_reverse
)
2338 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2340 /* Now process the alist elements in reverse of specified order. */
2341 for (i
--; i
>= 0; i
--)
2343 Lisp_Object prop
= parms
[i
];
2344 Lisp_Object val
= values
[i
];
2346 if (EQ (prop
, Qforeground_color
))
2348 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2349 ? LFACE_BACKGROUND_INDEX
2350 : LFACE_FOREGROUND_INDEX
);
2351 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2352 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2353 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2356 /* FIXME: should the fore-/background of the default
2357 face change here as well? */
2358 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2360 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2364 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2367 else if (EQ (prop
, Qbackground_color
))
2369 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2370 ? LFACE_FOREGROUND_INDEX
2371 : LFACE_BACKGROUND_INDEX
);
2372 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2373 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2374 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2377 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2379 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2383 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2386 else if (EQ (prop
, Qtitle
))
2388 x_set_title (f
, val
);
2390 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2392 else if (EQ (prop
, Qcursor_type
))
2394 IT_set_cursor_type (f
, val
);
2396 fprintf (termscript
, "<CTYPE: %s>\n",
2397 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2400 store_frame_param (f
, prop
, val
);
2403 /* If they specified "reverse", but not the colors, we need to swap
2404 the current frame colors. */
2405 if (reverse
&& !was_reverse
)
2409 FRAME_BACKGROUND_PIXEL (f
) = orig_fg
;
2414 FRAME_FOREGROUND_PIXEL (f
) = orig_bg
;
2421 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2422 if (f
== SELECTED_FRAME())
2427 extern void init_frame_faces (FRAME_PTR
);
2429 #endif /* !HAVE_X_WINDOWS */
2432 /* Do we need the internal terminal? */
2435 internal_terminal_init ()
2437 char *term
= getenv ("TERM");
2439 struct frame
*sf
= SELECTED_FRAME();
2441 #ifdef HAVE_X_WINDOWS
2442 if (!inhibit_window_system
)
2447 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2449 if (getenv ("EMACSTEST"))
2450 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2452 #ifndef HAVE_X_WINDOWS
2453 if (!internal_terminal
|| inhibit_window_system
)
2455 sf
->output_method
= output_termcap
;
2459 Vwindow_system
= intern ("pc");
2460 Vwindow_system_version
= make_number (1);
2461 sf
->output_method
= output_msdos_raw
;
2463 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2464 screen_old_address
= 0;
2466 /* Forget the stale screen colors as well. */
2467 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2469 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2470 the_only_x_display
.background_pixel
= 7; /* White */
2471 the_only_x_display
.foreground_pixel
= 0; /* Black */
2473 colors
= getenv ("EMACSCOLORS");
2474 if (colors
&& strlen (colors
) >= 2)
2476 /* The colors use 4 bits each (we enable bright background). */
2477 if (isdigit (colors
[0]))
2479 else if (isxdigit (colors
[0]))
2480 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2481 if (colors
[0] >= 0 && colors
[0] < 16)
2482 the_only_x_display
.foreground_pixel
= colors
[0];
2483 if (isdigit (colors
[1]))
2485 else if (isxdigit (colors
[1]))
2486 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2487 if (colors
[1] >= 0 && colors
[1] < 16)
2488 the_only_x_display
.background_pixel
= colors
[1];
2490 the_only_x_display
.line_height
= 1;
2491 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2492 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2493 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2494 the_only_x_display
.display_info
.mouse_face_beg_row
=
2495 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2496 the_only_x_display
.display_info
.mouse_face_end_row
=
2497 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2498 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2499 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2500 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2501 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2502 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2504 init_frame_faces (sf
);
2506 ring_bell_hook
= IT_ring_bell
;
2507 insert_glyphs_hook
= IT_insert_glyphs
;
2508 delete_glyphs_hook
= IT_delete_glyphs
;
2509 write_glyphs_hook
= IT_write_glyphs
;
2510 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2511 clear_to_end_hook
= IT_clear_to_end
;
2512 clear_end_of_line_hook
= IT_clear_end_of_line
;
2513 clear_frame_hook
= IT_clear_screen
;
2514 change_line_highlight_hook
= IT_change_line_highlight
;
2515 update_begin_hook
= IT_update_begin
;
2516 update_end_hook
= IT_update_end
;
2517 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2518 frame_up_to_date_hook
= IT_frame_up_to_date
;
2520 /* These hooks are called by term.c without being checked. */
2521 set_terminal_modes_hook
= IT_set_terminal_modes
;
2522 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2523 set_terminal_window_hook
= IT_set_terminal_window
;
2524 char_ins_del_ok
= 0;
2528 dos_get_saved_screen (screen
, rows
, cols
)
2533 #ifndef HAVE_X_WINDOWS
2534 *screen
= startup_screen_buffer
;
2535 *cols
= startup_screen_size_X
;
2536 *rows
= startup_screen_size_Y
;
2537 return *screen
!= (char *)0;
2543 #ifndef HAVE_X_WINDOWS
2545 /* We are not X, but we can emulate it well enough for our needs... */
2549 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2550 error ("Not running under a window system");
2556 /* ----------------------- Keyboard control ----------------------
2558 * Keymaps reflect the following keyboard layout:
2560 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2561 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2562 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2563 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2567 #define Ignore 0x0000
2568 #define Normal 0x0000 /* normal key - alt changes scan-code */
2569 #define FctKey 0x1000 /* func key if c == 0, else c */
2570 #define Special 0x2000 /* func key even if c != 0 */
2571 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2572 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2573 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2574 #define Grey 0x6000 /* Grey keypad key */
2576 #define Alt 0x0100 /* alt scan-code */
2577 #define Ctrl 0x0200 /* ctrl scan-code */
2578 #define Shift 0x0400 /* shift scan-code */
2580 static int extended_kbd
; /* 101 (102) keyboard present. */
2582 struct kbd_translate
{
2585 unsigned short code
;
2588 struct dos_keyboard_map
2593 struct kbd_translate
*translate_table
;
2597 static struct dos_keyboard_map us_keyboard
= {
2599 /* 01234567890123456789012345678901234567890 12345678901234 */
2600 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2601 /* 0123456789012345678901234567890123456789 012345678901234 */
2602 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2603 0, /* no Alt-Gr key */
2604 0 /* no translate table */
2607 static struct dos_keyboard_map fr_keyboard
= {
2609 /* 012 3456789012345678901234567890123456789012345678901234 */
2610 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2611 /* 0123456789012345678901234567890123456789012345678901234 */
2612 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2613 /* 01234567 89012345678901234567890123456789012345678901234 */
2615 0 /* no translate table */
2619 * Italian keyboard support, country code 39.
2622 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2623 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2626 static struct kbd_translate it_kbd_translate_table
[] = {
2627 { 0x56, 0x3c, Normal
| 13 },
2628 { 0x56, 0x3e, Normal
| 27 },
2631 static struct dos_keyboard_map it_keyboard
= {
2633 /* 0 123456789012345678901234567890123456789012345678901234 */
2634 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2635 /* 01 23456789012345678901234567890123456789012345678901234 */
2636 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2637 /* 0123456789012345678901234567890123456789012345678901234 */
2639 it_kbd_translate_table
2642 static struct dos_keyboard_map dk_keyboard
= {
2644 /* 0123456789012345678901234567890123456789012345678901234 */
2645 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2646 /* 01 23456789012345678901234567890123456789012345678901234 */
2647 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2648 /* 0123456789012345678901234567890123456789012345678901234 */
2650 0 /* no translate table */
2653 static struct kbd_translate jp_kbd_translate_table
[] = {
2654 { 0x73, 0x5c, Normal
| 0 },
2655 { 0x73, 0x5f, Normal
| 0 },
2656 { 0x73, 0x1c, Map
| 0 },
2657 { 0x7d, 0x5c, Normal
| 13 },
2658 { 0x7d, 0x7c, Normal
| 13 },
2659 { 0x7d, 0x1c, Map
| 13 },
2662 static struct dos_keyboard_map jp_keyboard
= {
2664 /* 0123456789012 345678901234567890123456789012345678901234 */
2665 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2666 /* 01 23456789012345678901234567890123456789012345678901234 */
2667 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2668 0, /* no Alt-Gr key */
2669 jp_kbd_translate_table
2672 static struct keyboard_layout_list
2675 struct dos_keyboard_map
*keyboard_map
;
2676 } keyboard_layout_list
[] =
2685 static struct dos_keyboard_map
*keyboard
;
2686 static int keyboard_map_all
;
2687 static int international_keyboard
;
2690 dos_set_keyboard (code
, always
)
2695 _go32_dpmi_registers regs
;
2697 /* See if Keyb.Com is installed (for international keyboard support).
2698 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2699 of Windows 9X! So don't do that! */
2701 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2702 _go32_dpmi_simulate_int (0x2f, ®s
);
2703 if (regs
.h
.al
== 0xff)
2704 international_keyboard
= 1;
2706 /* Initialize to US settings, for countries that don't have their own. */
2707 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2708 keyboard_map_all
= always
;
2709 dos_keyboard_layout
= 1;
2711 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2712 if (code
== keyboard_layout_list
[i
].country_code
)
2714 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2715 keyboard_map_all
= always
;
2716 dos_keyboard_layout
= code
;
2724 unsigned char char_code
; /* normal code */
2725 unsigned char meta_code
; /* M- code */
2726 unsigned char keypad_code
; /* keypad code */
2727 unsigned char editkey_code
; /* edit key */
2728 } keypad_translate_map
[] = {
2729 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2730 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2731 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2732 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2733 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2734 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2735 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2736 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2737 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2738 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2739 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2744 unsigned char char_code
; /* normal code */
2745 unsigned char keypad_code
; /* keypad code */
2746 } grey_key_translate_map
[] = {
2747 '/', 0xaf, /* kp-decimal */
2748 '*', 0xaa, /* kp-multiply */
2749 '-', 0xad, /* kp-subtract */
2750 '+', 0xab, /* kp-add */
2751 '\r', 0x8d /* kp-enter */
2754 static unsigned short
2755 ibmpc_translate_map
[] =
2757 /* --------------- 00 to 0f --------------- */
2758 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2759 Alt
| ModFct
| 0x1b, /* Escape */
2760 Normal
| 1, /* '1' */
2761 Normal
| 2, /* '2' */
2762 Normal
| 3, /* '3' */
2763 Normal
| 4, /* '4' */
2764 Normal
| 5, /* '5' */
2765 Normal
| 6, /* '6' */
2766 Normal
| 7, /* '7' */
2767 Normal
| 8, /* '8' */
2768 Normal
| 9, /* '9' */
2769 Normal
| 10, /* '0' */
2770 Normal
| 11, /* '-' */
2771 Normal
| 12, /* '=' */
2772 Special
| 0x08, /* Backspace */
2773 ModFct
| 0x74, /* Tab/Backtab */
2775 /* --------------- 10 to 1f --------------- */
2788 ModFct
| 0x0d, /* Return */
2793 /* --------------- 20 to 2f --------------- */
2802 Map
| 40, /* '\'' */
2804 Ignore
, /* Left shift */
2805 Map
| 41, /* '\\' */
2811 /* --------------- 30 to 3f --------------- */
2818 Ignore
, /* Right shift */
2819 Grey
| 1, /* Grey * */
2821 Normal
| 55, /* ' ' */
2822 Ignore
, /* Caps Lock */
2823 FctKey
| 0xbe, /* F1 */
2824 FctKey
| 0xbf, /* F2 */
2825 FctKey
| 0xc0, /* F3 */
2826 FctKey
| 0xc1, /* F4 */
2827 FctKey
| 0xc2, /* F5 */
2829 /* --------------- 40 to 4f --------------- */
2830 FctKey
| 0xc3, /* F6 */
2831 FctKey
| 0xc4, /* F7 */
2832 FctKey
| 0xc5, /* F8 */
2833 FctKey
| 0xc6, /* F9 */
2834 FctKey
| 0xc7, /* F10 */
2835 Ignore
, /* Num Lock */
2836 Ignore
, /* Scroll Lock */
2837 KeyPad
| 7, /* Home */
2838 KeyPad
| 8, /* Up */
2839 KeyPad
| 9, /* Page Up */
2840 Grey
| 2, /* Grey - */
2841 KeyPad
| 4, /* Left */
2842 KeyPad
| 5, /* Keypad 5 */
2843 KeyPad
| 6, /* Right */
2844 Grey
| 3, /* Grey + */
2845 KeyPad
| 1, /* End */
2847 /* --------------- 50 to 5f --------------- */
2848 KeyPad
| 2, /* Down */
2849 KeyPad
| 3, /* Page Down */
2850 KeyPad
| 0, /* Insert */
2851 KeyPad
| 10, /* Delete */
2852 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2853 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2854 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2855 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2856 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2857 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2858 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2859 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2860 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2861 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2862 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2863 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2865 /* --------------- 60 to 6f --------------- */
2866 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2867 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2868 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2869 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2870 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2871 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2872 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2873 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2874 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2875 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2876 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2877 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2878 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2879 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2880 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2881 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2883 /* --------------- 70 to 7f --------------- */
2884 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2885 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2886 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2887 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2888 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2889 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2890 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2891 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2892 Alt
| Map
| 1, /* '1' */
2893 Alt
| Map
| 2, /* '2' */
2894 Alt
| Map
| 3, /* '3' */
2895 Alt
| Map
| 4, /* '4' */
2896 Alt
| Map
| 5, /* '5' */
2897 Alt
| Map
| 6, /* '6' */
2898 Alt
| Map
| 7, /* '7' */
2899 Alt
| Map
| 8, /* '8' */
2901 /* --------------- 80 to 8f --------------- */
2902 Alt
| Map
| 9, /* '9' */
2903 Alt
| Map
| 10, /* '0' */
2904 Alt
| Map
| 11, /* '-' */
2905 Alt
| Map
| 12, /* '=' */
2906 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2907 FctKey
| 0xc8, /* F11 */
2908 FctKey
| 0xc9, /* F12 */
2909 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2910 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2911 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2912 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2913 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2914 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2915 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2916 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2917 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2919 /* --------------- 90 to 9f --------------- */
2920 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2921 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2922 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2923 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2924 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2925 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2926 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2927 Alt
| FctKey
| 0x50, /* (Alt) Home */
2928 Alt
| FctKey
| 0x52, /* (Alt) Up */
2929 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2930 Ignore
, /* NO KEY */
2931 Alt
| FctKey
| 0x51, /* (Alt) Left */
2932 Ignore
, /* NO KEY */
2933 Alt
| FctKey
| 0x53, /* (Alt) Right */
2934 Ignore
, /* NO KEY */
2935 Alt
| FctKey
| 0x57, /* (Alt) End */
2937 /* --------------- a0 to af --------------- */
2938 Alt
| KeyPad
| 2, /* (Alt) Down */
2939 Alt
| KeyPad
| 3, /* (Alt) Page Down */
2940 Alt
| KeyPad
| 0, /* (Alt) Insert */
2941 Alt
| KeyPad
| 10, /* (Alt) Delete */
2942 Alt
| Grey
| 0, /* (Alt) Grey / */
2943 Alt
| FctKey
| 0x09, /* (Alt) Tab */
2944 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
2947 /* These bit-positions corresponds to values returned by BIOS */
2948 #define SHIFT_P 0x0003 /* two bits! */
2949 #define CTRL_P 0x0004
2950 #define ALT_P 0x0008
2951 #define SCRLOCK_P 0x0010
2952 #define NUMLOCK_P 0x0020
2953 #define CAPSLOCK_P 0x0040
2954 #define ALT_GR_P 0x0800
2955 #define SUPER_P 0x4000 /* pseudo */
2956 #define HYPER_P 0x8000 /* pseudo */
2959 dos_get_modifiers (keymask
)
2966 /* Calculate modifier bits */
2967 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
2968 int86 (0x16, ®s
, ®s
);
2972 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
2973 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2977 mask
= regs
.h
.al
& (SHIFT_P
|
2978 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2980 /* Do not break international keyboard support. */
2981 /* When Keyb.Com is loaded, the right Alt key is */
2982 /* used for accessing characters like { and } */
2983 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
2986 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
2989 if (dos_hyper_key
== 1)
2992 modifiers
|= hyper_modifier
;
2994 else if (dos_super_key
== 1)
2997 modifiers
|= super_modifier
;
2999 else if (!international_keyboard
)
3001 /* If Keyb.Com is NOT installed, let Right Alt behave
3002 like the Left Alt. */
3008 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3011 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3013 if (dos_hyper_key
== 2)
3016 modifiers
|= hyper_modifier
;
3018 else if (dos_super_key
== 2)
3021 modifiers
|= super_modifier
;
3029 modifiers
|= shift_modifier
;
3031 modifiers
|= ctrl_modifier
;
3033 modifiers
|= meta_modifier
;
3040 #define NUM_RECENT_DOSKEYS (100)
3041 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3042 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3043 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3045 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3046 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3047 Each input key receives two values in this vector: first the ASCII code,\n\
3048 and then the scan code.")
3051 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3054 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3055 return Fvector (total_doskeys
, keys
);
3058 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3059 bcopy (keys
+ recent_doskeys_index
,
3060 XVECTOR (val
)->contents
,
3061 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3063 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3064 recent_doskeys_index
* sizeof (Lisp_Object
));
3069 /* Get a char from keyboard. Function keys are put into the event queue. */
3073 struct input_event event
;
3076 #ifndef HAVE_X_WINDOWS
3077 /* Maybe put the cursor where it should be. */
3078 IT_cmgoto (SELECTED_FRAME());
3081 /* The following condition is equivalent to `kbhit ()', except that
3082 it uses the bios to do its job. This pleases DESQview/X. */
3083 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3084 int86 (0x16, ®s
, ®s
),
3085 (regs
.x
.flags
& 0x40) == 0)
3088 register unsigned char c
;
3089 int sc
, code
= -1, mask
, kp_mode
;
3092 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3093 int86 (0x16, ®s
, ®s
);
3098 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3100 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3101 recent_doskeys_index
= 0;
3102 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3104 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3105 recent_doskeys_index
= 0;
3107 modifiers
= dos_get_modifiers (&mask
);
3109 #ifndef HAVE_X_WINDOWS
3110 if (!NILP (Vdos_display_scancodes
))
3113 sprintf (buf
, "%02x:%02x*%04x",
3114 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3115 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3123 case 10: /* Ctrl Grey Enter */
3124 code
= Ctrl
| Grey
| 4;
3126 case 13: /* Grey Enter */
3129 case '/': /* Grey / */
3139 /* Try the keyboard-private translation table first. */
3140 if (keyboard
->translate_table
)
3142 struct kbd_translate
*p
= keyboard
->translate_table
;
3146 if (p
->sc
== sc
&& p
->ch
== c
)
3154 /* If the private table didn't translate it, use the general
3158 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3160 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3167 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3168 Emacs is ready to read a key. Therefore, if they press
3169 `Alt-x' when Emacs is busy, by the time we get to
3170 `dos_get_modifiers', they might have already released the
3171 Alt key, and Emacs gets just `x', which is BAD.
3172 However, for keys with the `Map' property set, the ASCII
3173 code returns zero iff Alt is pressed. So, when we DON'T
3174 have to support international_keyboard, we don't have to
3175 distinguish between the left and right Alt keys, and we
3176 can set the META modifier for any keys with the `Map'
3177 property if they return zero ASCII code (c = 0). */
3179 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3180 modifiers
|= meta_modifier
;
3182 modifiers
|= ctrl_modifier
;
3184 modifiers
|= shift_modifier
;
3187 switch (code
& 0xf000)
3190 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3192 c
= 0; /* Special */
3205 if (c
== 0) /* ctrl-break */
3207 return c
; /* ALT-nnn */
3209 if (!keyboard_map_all
)
3218 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3219 if (!keyboard_map_all
)
3223 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3224 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3228 code
= keyboard
->shifted
[code
];
3230 modifiers
&= ~shift_modifier
;
3233 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3234 code
= keyboard
->alt_gr
[code
];
3236 code
= keyboard
->unshifted
[code
];
3241 if (c
== 0xe0) /* edit key */
3244 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3245 kp_mode
= dos_keypad_mode
& 0x03;
3247 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3252 if (code
== 10 && dos_decimal_point
)
3253 return dos_decimal_point
;
3254 return keypad_translate_map
[code
].char_code
;
3257 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3261 code
= keypad_translate_map
[code
].meta_code
;
3262 modifiers
= meta_modifier
;
3266 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3273 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3274 if (dos_keypad_mode
& kp_mode
)
3275 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3277 code
= grey_key_translate_map
[code
].char_code
;
3286 event
.kind
= non_ascii_keystroke
;
3288 event
.kind
= ascii_keystroke
;
3290 event
.modifiers
= modifiers
;
3291 event
.frame_or_window
= selected_frame
;
3293 event
.timestamp
= event_timestamp ();
3294 kbd_buffer_store_event (&event
);
3297 if (have_mouse
> 0 && !mouse_preempted
)
3299 int but
, press
, x
, y
, ok
;
3300 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3302 /* Check for mouse movement *before* buttons. */
3303 mouse_check_moved ();
3305 /* If the mouse moved from the spot of its last sighting, we
3306 might need to update mouse highlight. */
3307 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3309 previous_help_echo
= help_echo
;
3310 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3312 IT_note_mouse_highlight (SELECTED_FRAME(),
3313 mouse_last_x
, mouse_last_y
);
3314 /* If the contents of the global variable help_echo has
3315 changed, generate a HELP_EVENT. */
3316 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3318 /* HELP_EVENT takes 2 events in the event loop. */
3319 event
.kind
= HELP_EVENT
;
3320 event
.frame_or_window
= selected_frame
;
3321 event
.arg
= help_echo_object
;
3322 event
.x
= make_number (help_echo_pos
);
3323 event
.timestamp
= event_timestamp ();
3325 kbd_buffer_store_event (&event
);
3326 if (WINDOWP (help_echo_window
))
3327 event
.frame_or_window
= help_echo_window
;
3328 event
.arg
= help_echo
;
3330 kbd_buffer_store_event (&event
);
3334 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3335 for (press
= 0; press
< 2; press
++)
3337 int button_num
= but
;
3340 ok
= mouse_pressed (but
, &x
, &y
);
3342 ok
= mouse_released (but
, &x
, &y
);
3345 /* Allow a simultaneous press/release of Mouse-1 and
3346 Mouse-2 to simulate Mouse-3 on two-button mice. */
3347 if (mouse_button_count
== 2 && but
< 2)
3349 int x2
, y2
; /* don't clobber original coordinates */
3351 /* If only one button is pressed, wait 100 msec and
3352 check again. This way, Speedy Gonzales isn't
3353 punished, while the slow get their chance. */
3354 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3355 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3360 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3361 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3366 event
.kind
= mouse_click
;
3367 event
.code
= button_num
;
3368 event
.modifiers
= dos_get_modifiers (0)
3369 | (press
? down_modifier
: up_modifier
);
3372 event
.frame_or_window
= selected_frame
;
3374 event
.timestamp
= event_timestamp ();
3375 kbd_buffer_store_event (&event
);
3383 static int prev_get_char
= -1;
3385 /* Return 1 if a key is ready to be read without suspending execution. */
3389 if (prev_get_char
!= -1)
3392 return ((prev_get_char
= dos_rawgetc ()) != -1);
3395 /* Read a key. Return -1 if no key is ready. */
3399 if (prev_get_char
!= -1)
3401 int c
= prev_get_char
;
3406 return dos_rawgetc ();
3409 #ifndef HAVE_X_WINDOWS
3410 /* See xterm.c for more info. */
3412 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3414 register int pix_x
, pix_y
;
3415 register int *x
, *y
;
3419 if (bounds
) abort ();
3421 /* Ignore clipping. */
3428 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3431 register int *pix_x
, *pix_y
;
3437 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3440 Actually, I don't know the meaning of all the parameters of the functions
3441 here -- I only know how they are called by xmenu.c. I could of course
3442 grab the nearest Xlib manual (down the hall, second-to-last door on the
3443 left), but I don't think it's worth the effort. */
3445 /* These hold text of the current and the previous menu help messages. */
3446 static char *menu_help_message
, *prev_menu_help_message
;
3447 /* Pane number and item number of the menu item which generated the
3448 last menu help message. */
3449 static int menu_help_paneno
, menu_help_itemno
;
3456 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3457 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3461 /* Allocate some (more) memory for MENU ensuring that there is room for one
3465 IT_menu_make_room (XMenu
*menu
)
3467 if (menu
->allocated
== 0)
3469 int count
= menu
->allocated
= 10;
3470 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3471 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3472 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3473 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3475 else if (menu
->allocated
== menu
->count
)
3477 int count
= menu
->allocated
= menu
->allocated
+ 10;
3479 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3481 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3483 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3485 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3489 /* Search the given menu structure for a given pane number. */
3492 IT_menu_search_pane (XMenu
*menu
, int pane
)
3497 for (i
= 0; i
< menu
->count
; i
++)
3498 if (menu
->submenu
[i
])
3500 if (pane
== menu
->panenumber
[i
])
3501 return menu
->submenu
[i
];
3502 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3508 /* Determine how much screen space a given menu needs. */
3511 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3513 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3516 maxheight
= menu
->count
;
3517 for (i
= 0; i
< menu
->count
; i
++)
3519 if (menu
->submenu
[i
])
3521 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3522 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3523 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3526 *width
= menu
->width
+ maxsubwidth
;
3527 *height
= maxheight
;
3530 /* Display MENU at (X,Y) using FACES. */
3533 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3535 int i
, j
, face
, width
;
3536 struct glyph
*text
, *p
;
3539 int enabled
, mousehere
;
3541 struct frame
*sf
= SELECTED_FRAME();
3543 menu_help_message
= NULL
;
3545 width
= menu
->width
;
3546 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3547 ScreenGetCursor (&row
, &col
);
3548 mouse_get_xy (&mx
, &my
);
3549 IT_update_begin (sf
);
3550 for (i
= 0; i
< menu
->count
; i
++)
3552 int max_width
= width
+ 2;
3554 IT_cursor_to (y
+ i
, x
);
3556 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3557 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3558 face
= faces
[enabled
+ mousehere
* 2];
3559 /* The following if clause means that we display the menu help
3560 strings even if the menu item is currently disabled. */
3561 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3563 menu_help_message
= menu
->help_text
[i
];
3564 menu_help_paneno
= pn
- 1;
3565 menu_help_itemno
= i
;
3568 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3570 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3574 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3577 else /* make '^x' */
3579 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3582 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3586 /* Don't let the menu text overflow into the next screen row. */
3587 if (x
+ max_width
> screen_size_X
)
3589 max_width
= screen_size_X
- x
;
3590 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3592 for (; j
< max_width
- 2; j
++, p
++)
3593 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3595 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3597 IT_write_glyphs (text
, max_width
);
3600 IT_cursor_to (row
, col
);
3604 /* --------------------------- X Menu emulation ---------------------- */
3606 /* Report availability of menus. */
3614 /* Create a brand new menu structure. */
3617 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3619 return IT_menu_create ();
3622 /* Create a new pane and place it on the outer-most level. It is not
3623 clear that it should be placed out there, but I don't know what else
3627 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3635 IT_menu_make_room (menu
);
3636 menu
->submenu
[menu
->count
] = IT_menu_create ();
3637 menu
->text
[menu
->count
] = txt
;
3638 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3639 menu
->help_text
[menu
->count
] = NULL
;
3642 /* Adjust length for possible control characters (which will
3643 be written as ^x). */
3644 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3648 if (len
> menu
->width
)
3651 return menu
->panecount
;
3654 /* Create a new item in a menu pane. */
3657 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3658 int foo
, char *txt
, int enable
, char *help_text
)
3664 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3666 IT_menu_make_room (menu
);
3667 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3668 menu
->text
[menu
->count
] = txt
;
3669 menu
->panenumber
[menu
->count
] = enable
;
3670 menu
->help_text
[menu
->count
] = help_text
;
3673 /* Adjust length for possible control characters (which will
3674 be written as ^x). */
3675 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3679 if (len
> menu
->width
)
3685 /* Decide where the menu would be placed if requested at (X,Y). */
3688 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3689 int *ulx
, int *uly
, int *width
, int *height
)
3691 IT_menu_calc_size (menu
, width
, height
);
3697 struct IT_menu_state
3699 void *screen_behind
;
3706 /* Display menu, wait for user's response, and return that response. */
3709 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3710 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3711 void (*help_callback
)(char *, int, int))
3713 struct IT_menu_state
*state
;
3718 Lisp_Object selectface
;
3719 int leave
, result
, onepane
;
3720 int title_faces
[4]; /* face to display the menu title */
3721 int buffers_num_deleted
= 0;
3722 struct frame
*sf
= SELECTED_FRAME();
3723 Lisp_Object saved_echo_area_message
;
3725 /* Just in case we got here without a mouse present... */
3726 if (have_mouse
<= 0)
3727 return XM_IA_SELECT
;
3728 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3729 around the display. */
3735 /* We will process all the mouse events directly, so we had
3736 better prevent dos_rawgetc from stealing them from us. */
3739 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3740 screensize
= screen_size
* 2;
3742 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3743 0, DEFAULT_FACE_ID
);
3745 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3746 0, DEFAULT_FACE_ID
);
3747 selectface
= intern ("msdos-menu-select-face");
3748 faces
[2] = lookup_derived_face (sf
, selectface
,
3750 faces
[3] = lookup_derived_face (sf
, selectface
,
3753 /* Make sure the menu title is always displayed with
3754 `msdos-menu-active-face', no matter where the mouse pointer is. */
3755 for (i
= 0; i
< 4; i
++)
3756 title_faces
[i
] = faces
[3];
3760 /* Don't let the title for the "Buffers" popup menu include a
3761 digit (which is ugly).
3763 This is a terrible kludge, but I think the "Buffers" case is
3764 the only one where the title includes a number, so it doesn't
3765 seem to be necessary to make this more general. */
3766 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3768 menu
->text
[0][7] = '\0';
3769 buffers_num_deleted
= 1;
3772 /* We need to save the current echo area message, so that we could
3773 restore it below, before we exit. See the commentary below,
3774 before the call to message_with_string. */
3775 saved_echo_area_message
= Fcurrent_message ();
3776 state
[0].menu
= menu
;
3778 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3780 /* Turn off the cursor. Otherwise it shows through the menu
3781 panes, which is ugly. */
3782 IT_display_cursor (0);
3784 /* Display the menu title. */
3785 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3786 if (buffers_num_deleted
)
3787 menu
->text
[0][7] = ' ';
3788 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3790 menu
->width
= menu
->submenu
[0]->width
;
3791 state
[0].menu
= menu
->submenu
[0];
3795 state
[0].menu
= menu
;
3797 state
[0].x
= x0
- 1;
3799 state
[0].pane
= onepane
;
3801 mouse_last_x
= -1; /* A hack that forces display. */
3805 if (!mouse_visible
) mouse_on ();
3806 mouse_check_moved ();
3807 if (sf
->mouse_moved
)
3809 sf
->mouse_moved
= 0;
3810 result
= XM_IA_SELECT
;
3811 mouse_get_xy (&x
, &y
);
3812 for (i
= 0; i
< statecount
; i
++)
3813 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3815 int dy
= y
- state
[i
].y
;
3816 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3818 if (!state
[i
].menu
->submenu
[dy
])
3819 if (state
[i
].menu
->panenumber
[dy
])
3820 result
= XM_SUCCESS
;
3822 result
= XM_IA_SELECT
;
3823 *pane
= state
[i
].pane
- 1;
3825 /* We hit some part of a menu, so drop extra menus that
3826 have been opened. That does not include an open and
3828 if (i
!= statecount
- 2
3829 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3830 while (i
!= statecount
- 1)
3834 ScreenUpdate (state
[statecount
].screen_behind
);
3835 if (screen_virtual_segment
)
3836 dosv_refresh_virtual_screen (0, screen_size
);
3837 xfree (state
[statecount
].screen_behind
);
3839 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3841 IT_menu_display (state
[i
].menu
,
3846 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3847 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3849 ScreenRetrieve (state
[statecount
].screen_behind
3850 = xmalloc (screensize
));
3852 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3853 state
[statecount
].y
= y
;
3858 IT_menu_display (state
[statecount
- 1].menu
,
3859 state
[statecount
- 1].y
,
3860 state
[statecount
- 1].x
,
3861 state
[statecount
- 1].pane
,
3866 if ((menu_help_message
|| prev_menu_help_message
)
3867 && menu_help_message
!= prev_menu_help_message
)
3869 help_callback (menu_help_message
,
3870 menu_help_paneno
, menu_help_itemno
);
3871 IT_display_cursor (0);
3872 prev_menu_help_message
= menu_help_message
;
3874 /* We are busy-waiting for the mouse to move, so let's be nice
3875 to other Windows applications by releasing our time slice. */
3878 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3880 /* Only leave if user both pressed and released the mouse, and in
3881 that order. This avoids popping down the menu pane unless
3882 the user is really done with it. */
3883 if (mouse_pressed (b
, &x
, &y
))
3885 while (mouse_button_depressed (b
, &x
, &y
))
3889 (void) mouse_released (b
, &x
, &y
);
3894 ScreenUpdate (state
[0].screen_behind
);
3895 if (screen_virtual_segment
)
3896 dosv_refresh_virtual_screen (0, screen_size
);
3898 /* We have a situation here. ScreenUpdate has just restored the
3899 screen contents as it was before we started drawing this menu.
3900 That includes any echo area message that could have been
3901 displayed back then. (In reality, that echo area message will
3902 almost always be the ``keystroke echo'' that echoes the sequence
3903 of menu items chosen by the user.) However, if the menu had some
3904 help messages, then displaying those messages caused Emacs to
3905 forget about the original echo area message. So when
3906 ScreenUpdate restored it, it created a discrepancy between the
3907 actual screen contents and what Emacs internal data structures
3910 To avoid this conflict, we force Emacs to restore the original
3911 echo area message as we found it when we entered this function.
3912 The irony of this is that we then erase the restored message
3913 right away, so the only purpose of restoring it is so that
3914 erasing it works correctly... */
3915 if (! NILP (saved_echo_area_message
))
3916 message_with_string ("%s", saved_echo_area_message
, 0);
3918 while (statecount
--)
3919 xfree (state
[statecount
].screen_behind
);
3920 IT_display_cursor (1); /* turn cursor back on */
3921 /* Clean up any mouse events that are waiting inside Emacs event queue.
3922 These events are likely to be generated before the menu was even
3923 displayed, probably because the user pressed and released the button
3924 (which invoked the menu) too quickly. If we don't remove these events,
3925 Emacs will process them after we return and surprise the user. */
3926 discard_mouse_events ();
3927 mouse_clear_clicks ();
3928 if (!kbd_buffer_events_waiting (1))
3929 clear_input_pending ();
3930 /* Allow mouse events generation by dos_rawgetc. */
3935 /* Dispose of a menu. */
3938 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3941 if (menu
->allocated
)
3943 for (i
= 0; i
< menu
->count
; i
++)
3944 if (menu
->submenu
[i
])
3945 XMenuDestroy (foo
, menu
->submenu
[i
]);
3947 xfree (menu
->submenu
);
3948 xfree (menu
->panenumber
);
3949 xfree (menu
->help_text
);
3952 menu_help_message
= prev_menu_help_message
= NULL
;
3956 x_pixel_width (struct frame
*f
)
3958 return FRAME_WIDTH (f
);
3962 x_pixel_height (struct frame
*f
)
3964 return FRAME_HEIGHT (f
);
3966 #endif /* !HAVE_X_WINDOWS */
3968 /* ----------------------- DOS / UNIX conversion --------------------- */
3970 void msdos_downcase_filename (unsigned char *);
3972 /* Destructively turn backslashes into slashes. */
3975 dostounix_filename (p
)
3978 msdos_downcase_filename (p
);
3988 /* Destructively turn slashes into backslashes. */
3991 unixtodos_filename (p
)
3994 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4008 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4011 getdefdir (drive
, dst
)
4015 char in_path
[4], *p
= in_path
;
4018 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4021 *p
++ = drive
+ 'A' - 1;
4028 _fixpath (in_path
, dst
);
4029 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4030 it queries the LFN support, so ignore that error. */
4031 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4034 msdos_downcase_filename (dst
);
4040 /* Remove all CR's that are followed by a LF. */
4045 register unsigned char *buf
;
4047 unsigned char *np
= buf
;
4048 unsigned char *startp
= buf
;
4049 unsigned char *endp
= buf
+ n
;
4053 while (buf
< endp
- 1)
4057 if (*(++buf
) != 0x0a)
4068 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4070 /* In DJGPP v2.0, library `write' can call `malloc', which might
4071 cause relocation of the buffer whose address we get in ADDR.
4072 Here is a version of `write' that avoids calling `malloc',
4073 to serve us until such time as the library is fixed.
4074 Actually, what we define here is called `__write', because
4075 `write' is a stub that just jmp's to `__write' (to be
4076 POSIXLY-correct with respect to the global name-space). */
4078 #include <io.h> /* for _write */
4079 #include <libc/dosio.h> /* for __file_handle_modes[] */
4081 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4083 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4086 __write (int handle
, const void *buffer
, size_t count
)
4091 if(__file_handle_modes
[handle
] & O_BINARY
)
4092 return _write (handle
, buffer
, count
);
4096 const char *bp
= buffer
;
4097 int total_written
= 0;
4098 int nmoved
= 0, ncr
= 0;
4102 /* The next test makes sure there's space for at least 2 more
4103 characters in xbuf[], so both CR and LF can be put there. */
4115 if (xbp
>= XBUF_END
|| !count
)
4117 size_t to_write
= nmoved
+ ncr
;
4118 int written
= _write (handle
, xbuf
, to_write
);
4123 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4125 /* If some, but not all were written (disk full?), return
4126 an estimate of the total written bytes not counting CRs. */
4127 if (written
< to_write
)
4128 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4135 return total_written
;
4139 /* A low-level file-renaming function which works around Windows 95 bug.
4140 This is pulled directly out of DJGPP v2.01 library sources, and only
4141 used when you compile with DJGPP v2.0. */
4145 int _rename(const char *old
, const char *new)
4148 int olen
= strlen(old
) + 1;
4150 int use_lfn
= _USE_LFN
;
4151 char tempfile
[FILENAME_MAX
];
4152 const char *orig
= old
;
4155 r
.x
.dx
= __tb_offset
;
4156 r
.x
.di
= __tb_offset
+ olen
;
4157 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4161 /* Windows 95 bug: for some filenames, when you rename
4162 file -> file~ (as in Emacs, to leave a backup), the
4163 short 8+3 alias doesn't change, which effectively
4164 makes OLD and NEW the same file. We must rename
4165 through a temporary file to work around this. */
4167 char *pbase
= 0, *p
;
4168 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4169 int idx
= sizeof(try_char
) - 1;
4171 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4172 might point to another drive, which will fail the DOS call. */
4173 strcpy(tempfile
, old
);
4174 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4175 if (*p
== '/' || *p
== '\\' || *p
== ':')
4181 strcpy(pbase
, "X$$djren$$.$$temp$$");
4187 *pbase
= try_char
[--idx
];
4188 } while (_chmod(tempfile
, 0) != -1);
4191 _put_path2(tempfile
, olen
);
4193 __dpmi_int(0x21, &r
);
4196 errno
= __doserr_to_errno(r
.x
.ax
);
4200 /* Now create a file with the original name. This will
4201 ensure that NEW will always have a 8+3 alias
4202 different from that of OLD. (Seems to be required
4203 when NameNumericTail in the Registry is set to 0.) */
4204 lfn_fd
= _creat(old
, 0);
4206 olen
= strlen(tempfile
) + 1;
4208 r
.x
.di
= __tb_offset
+ olen
;
4217 _put_path2(new, olen
);
4219 __dpmi_int(0x21, &r
);
4222 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4223 remove(new); /* and try again */
4226 errno
= __doserr_to_errno(r
.x
.ax
);
4228 /* Restore to original name if we renamed it to temporary. */
4236 _put_path2(orig
, olen
);
4237 _put_path(tempfile
);
4239 __dpmi_int(0x21, &r
);
4248 /* Success. Delete the file possibly created to work
4249 around the Windows 95 bug. */
4251 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4255 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4257 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4259 "Return non-nil if long file names are supported on MSDOS.")
4262 return (_USE_LFN
? Qt
: Qnil
);
4265 /* Convert alphabetic characters in a filename to lower-case. */
4268 msdos_downcase_filename (p
)
4269 register unsigned char *p
;
4271 /* Always lower-case drive letters a-z, even if the filesystem
4272 preserves case in filenames.
4273 This is so MSDOS filenames could be compared by string comparison
4274 functions that are case-sensitive. Even case-preserving filesystems
4275 do not distinguish case in drive letters. */
4276 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4282 /* Under LFN we expect to get pathnames in their true case. */
4283 if (NILP (Fmsdos_long_file_names ()))
4285 if (*p
>= 'A' && *p
<= 'Z')
4289 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4291 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4292 When long filenames are supported, doesn't change FILENAME.\n\
4293 If FILENAME is not a string, returns nil.\n\
4294 The argument object is never altered--the value is a copy.")
4296 Lisp_Object filename
;
4300 if (! STRINGP (filename
))
4303 tem
= Fcopy_sequence (filename
);
4304 msdos_downcase_filename (XSTRING (tem
)->data
);
4308 /* The Emacs root directory as determined by init_environment. */
4310 static char emacsroot
[MAXPATHLEN
];
4313 rootrelativepath (rel
)
4316 static char result
[MAXPATHLEN
+ 10];
4318 strcpy (result
, emacsroot
);
4319 strcat (result
, "/");
4320 strcat (result
, rel
);
4324 /* Define a lot of environment variables if not already defined. Don't
4325 remove anything unless you know what you're doing -- lots of code will
4326 break if one or more of these are missing. */
4329 init_environment (argc
, argv
, skip_args
)
4336 static const char * const tempdirs
[] = {
4337 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4340 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4342 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4343 temporary files and assume "/tmp" if $TMPDIR is unset, which
4344 will break on DOS/Windows. Refuse to work if we cannot find
4345 a directory, not even "c:/", usable for that purpose. */
4346 for (i
= 0; i
< imax
; i
++)
4348 const char *tmp
= tempdirs
[i
];
4351 tmp
= getenv (tmp
+ 1);
4352 /* Note that `access' can lie to us if the directory resides on a
4353 read-only filesystem, like CD-ROM or a write-protected floppy.
4354 The only way to be really sure is to actually create a file and
4355 see if it succeeds. But I think that's too much to ask. */
4356 if (tmp
&& access (tmp
, D_OK
) == 0)
4358 setenv ("TMPDIR", tmp
, 1);
4365 Fcons (build_string ("no usable temporary directories found!!"),
4367 "While setting TMPDIR: ");
4369 /* Note the startup time, so we know not to clear the screen if we
4370 exit immediately; see IT_reset_terminal_modes.
4371 (Yes, I know `clock' returns zero the first time it's called, but
4372 I do this anyway, in case some wiseguy changes that at some point.) */
4373 startup_time
= clock ();
4375 /* Find our root from argv[0]. Assuming argv[0] is, say,
4376 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4377 root
= alloca (MAXPATHLEN
+ 20);
4378 _fixpath (argv
[0], root
);
4379 msdos_downcase_filename (root
);
4380 len
= strlen (root
);
4381 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4385 && (strcmp (root
+ len
- 4, "/bin") == 0
4386 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4387 root
[len
- 4] = '\0';
4389 strcpy (root
, "c:/emacs"); /* let's be defensive */
4390 len
= strlen (root
);
4391 strcpy (emacsroot
, root
);
4393 /* We default HOME to our root. */
4394 setenv ("HOME", root
, 0);
4396 /* We default EMACSPATH to root + "/bin". */
4397 strcpy (root
+ len
, "/bin");
4398 setenv ("EMACSPATH", root
, 0);
4400 /* I don't expect anybody to ever use other terminals so the internal
4401 terminal is the default. */
4402 setenv ("TERM", "internal", 0);
4404 #ifdef HAVE_X_WINDOWS
4405 /* Emacs expects DISPLAY to be set. */
4406 setenv ("DISPLAY", "unix:0.0", 0);
4409 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4410 downcase it and mirror the backslashes. */
4411 s
= getenv ("COMSPEC");
4412 if (!s
) s
= "c:/command.com";
4413 t
= alloca (strlen (s
) + 1);
4415 dostounix_filename (t
);
4416 setenv ("SHELL", t
, 0);
4418 /* PATH is also downcased and backslashes mirrored. */
4419 s
= getenv ("PATH");
4421 t
= alloca (strlen (s
) + 3);
4422 /* Current directory is always considered part of MsDos's path but it is
4423 not normally mentioned. Now it is. */
4424 strcat (strcpy (t
, ".;"), s
);
4425 dostounix_filename (t
); /* Not a single file name, but this should work. */
4426 setenv ("PATH", t
, 1);
4428 /* In some sense all dos users have root privileges, so... */
4429 setenv ("USER", "root", 0);
4430 setenv ("NAME", getenv ("USER"), 0);
4432 /* Time zone determined from country code. To make this possible, the
4433 country code may not span more than one time zone. In other words,
4434 in the USA, you lose. */
4436 switch (dos_country_code
)
4438 case 31: /* Belgium */
4439 case 32: /* The Netherlands */
4440 case 33: /* France */
4441 case 34: /* Spain */
4442 case 36: /* Hungary */
4443 case 38: /* Yugoslavia (or what's left of it?) */
4444 case 39: /* Italy */
4445 case 41: /* Switzerland */
4446 case 42: /* Tjekia */
4447 case 45: /* Denmark */
4448 case 46: /* Sweden */
4449 case 47: /* Norway */
4450 case 48: /* Poland */
4451 case 49: /* Germany */
4452 /* Daylight saving from last Sunday in March to last Sunday in
4453 September, both at 2AM. */
4454 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4456 case 44: /* United Kingdom */
4457 case 351: /* Portugal */
4458 case 354: /* Iceland */
4459 setenv ("TZ", "GMT+00", 0);
4461 case 81: /* Japan */
4462 case 82: /* Korea */
4463 setenv ("TZ", "JST-09", 0);
4465 case 90: /* Turkey */
4466 case 358: /* Finland */
4467 setenv ("TZ", "EET-02", 0);
4469 case 972: /* Israel */
4470 /* This is an approximation. (For exact rules, use the
4471 `zoneinfo/israel' file which comes with DJGPP, but you need
4472 to install it in `/usr/share/zoneinfo/' directory first.) */
4473 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4481 static int break_stat
; /* BREAK check mode status. */
4482 static int stdin_stat
; /* stdin IOCTL status. */
4486 /* These must be global. */
4487 static _go32_dpmi_seginfo ctrl_break_vector
;
4488 static _go32_dpmi_registers ctrl_break_regs
;
4489 static int ctrlbreakinstalled
= 0;
4491 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4494 ctrl_break_func (regs
)
4495 _go32_dpmi_registers
*regs
;
4501 install_ctrl_break_check ()
4503 if (!ctrlbreakinstalled
)
4505 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4506 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4507 ctrlbreakinstalled
= 1;
4508 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4509 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4511 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4515 #endif /* __DJGPP__ < 2 */
4517 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4518 control chars by DOS. Determine the keyboard type. */
4523 union REGS inregs
, outregs
;
4524 static int first_time
= 1;
4526 break_stat
= getcbrk ();
4529 install_ctrl_break_check ();
4535 int86 (0x15, &inregs
, &outregs
);
4536 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4540 if (internal_terminal
4541 #ifdef HAVE_X_WINDOWS
4542 && inhibit_window_system
4546 inregs
.x
.ax
= 0x0021;
4547 int86 (0x33, &inregs
, &outregs
);
4548 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4551 /* Reportedly, the above doesn't work for some mouse drivers. There
4552 is an additional detection method that should work, but might be
4553 a little slower. Use that as an alternative. */
4554 inregs
.x
.ax
= 0x0000;
4555 int86 (0x33, &inregs
, &outregs
);
4556 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4561 have_mouse
= 1; /* enable mouse */
4563 mouse_setup_buttons (outregs
.x
.bx
);
4564 mouse_position_hook
= &mouse_get_pos
;
4568 #ifndef HAVE_X_WINDOWS
4570 /* Save the cursor shape used outside Emacs. */
4571 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4580 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4581 return (stdin_stat
!= -1);
4584 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4586 #else /* __DJGPP__ < 2 */
4590 /* I think it is wrong to overwrite `stdin_stat' every time
4591 but the first one this function is called, but I don't
4592 want to change the way it used to work in v1.x.--EZ */
4594 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4595 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4596 intdos (&inregs
, &outregs
);
4597 stdin_stat
= outregs
.h
.dl
;
4599 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4600 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4601 intdos (&inregs
, &outregs
);
4602 return !outregs
.x
.cflag
;
4604 #endif /* __DJGPP__ < 2 */
4607 /* Restore status of standard input and Ctrl-C checking. */
4612 union REGS inregs
, outregs
;
4614 setcbrk (break_stat
);
4619 #ifndef HAVE_X_WINDOWS
4620 /* Restore the cursor shape we found on startup. */
4624 inregs
.x
.cx
= outside_cursor
;
4625 int86 (0x10, &inregs
, &outregs
);
4629 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4631 #else /* not __DJGPP__ >= 2 */
4633 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4634 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4635 inregs
.x
.dx
= stdin_stat
;
4636 intdos (&inregs
, &outregs
);
4637 return !outregs
.x
.cflag
;
4639 #endif /* not __DJGPP__ >= 2 */
4643 /* Run command as specified by ARGV in directory DIR.
4644 The command is run with input from TEMPIN, output to
4645 file TEMPOUT and stderr to TEMPERR. */
4648 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4649 unsigned char **argv
;
4650 const char *working_dir
;
4651 int tempin
, tempout
, temperr
;
4654 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4655 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4656 int msshell
, result
= -1;
4657 int inbak
, outbak
, errbak
;
4661 /* Get current directory as MSDOS cwd is not per-process. */
4664 /* If argv[0] is the shell, it might come in any lettercase.
4665 Since `Fmember' is case-sensitive, we need to downcase
4666 argv[0], even if we are on case-preserving filesystems. */
4667 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4668 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4671 if (*pl
>= 'A' && *pl
<= 'Z')
4676 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4677 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4678 && !strcmp ("-c", argv
[1]);
4681 saveargv1
= argv
[1];
4682 saveargv2
= argv
[2];
4684 /* We only need to mirror slashes if a DOS shell will be invoked
4685 not via `system' (which does the mirroring itself). Yes, that
4686 means DJGPP v1.x will lose here. */
4687 if (argv
[2] && argv
[3])
4689 char *p
= alloca (strlen (argv
[2]) + 1);
4691 strcpy (argv
[2] = p
, saveargv2
);
4692 while (*p
&& isspace (*p
))
4704 chdir (working_dir
);
4708 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4709 goto done
; /* Allocation might fail due to lack of descriptors. */
4712 mouse_get_xy (&x
, &y
);
4714 dos_ttcooked (); /* do it here while 0 = stdin */
4722 if (msshell
&& !argv
[3])
4724 /* MS-DOS native shells are too restrictive. For starters, they
4725 cannot grok commands longer than 126 characters. In DJGPP v2
4726 and later, `system' is much smarter, so we'll call it instead. */
4730 /* A shell gets a single argument--its full command
4731 line--whose original was saved in `saveargv2'. */
4733 /* Don't let them pass empty command lines to `system', since
4734 with some shells it will try to invoke an interactive shell,
4735 which will hang Emacs. */
4736 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4740 extern char **environ
;
4741 char **save_env
= environ
;
4742 int save_system_flags
= __system_flags
;
4744 /* Request the most powerful version of `system'. We need
4745 all the help we can get to avoid calling stock DOS shells. */
4746 __system_flags
= (__system_redirect
4747 | __system_use_shell
4748 | __system_allow_multiple_cmds
4749 | __system_allow_long_cmds
4750 | __system_handle_null_commands
4751 | __system_emulate_chdir
);
4754 result
= system (cmnd
);
4755 __system_flags
= save_system_flags
;
4759 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4763 #endif /* __DJGPP__ > 1 */
4765 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4770 emacs_close (inbak
);
4771 emacs_close (outbak
);
4772 emacs_close (errbak
);
4778 mouse_moveto (x
, y
);
4781 /* Some programs might change the meaning of the highest bit of the
4782 text attribute byte, so we get blinking characters instead of the
4783 bright background colors. Restore that. */
4790 argv
[1] = saveargv1
;
4791 argv
[2] = saveargv2
;
4799 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4806 /* ------------------------- Compatibility functions -------------------
4811 /* Hostnames for a pc are not really funny,
4812 but they are used in change log so we emulate the best we can. */
4814 gethostname (p
, size
)
4818 char *q
= egetenv ("HOSTNAME");
4825 /* When time zones are set from Ms-Dos too many C-libraries are playing
4826 tricks with time values. We solve this by defining our own version
4827 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4828 once and after each call to `tzset' with TZ changed. That is
4829 accomplished by aliasing tzset to init_gettimeofday. */
4831 static struct tm time_rec
;
4834 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4842 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4846 time_rec
.tm_year
= d
.da_year
- 1900;
4847 time_rec
.tm_mon
= d
.da_mon
- 1;
4848 time_rec
.tm_mday
= d
.da_day
;
4851 time_rec
.tm_hour
= t
.ti_hour
;
4852 time_rec
.tm_min
= t
.ti_min
;
4853 time_rec
.tm_sec
= t
.ti_sec
;
4856 tm
.tm_gmtoff
= dos_timezone_offset
;
4858 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4859 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4861 /* Ignore tzp; it's obsolescent. */
4865 #endif /* __DJGPP__ < 2 */
4868 * A list of unimplemented functions that we silently ignore.
4872 unsigned alarm (s
) unsigned s
; {}
4873 fork () { return 0; }
4874 int kill (x
, y
) int x
, y
; { return -1; }
4876 void volatile pause () {}
4877 sigsetmask (x
) int x
; { return 0; }
4878 sigblock (mask
) int mask
; { return 0; }
4881 void request_sigio (void) {}
4882 setpgrp () {return 0; }
4883 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4884 void unrequest_sigio (void) {}
4888 #ifdef POSIX_SIGNALS
4890 /* Augment DJGPP library POSIX signal functions. This is needed
4891 as of DJGPP v2.01, but might be in the library in later releases. */
4893 #include <libc/bss.h>
4895 /* A counter to know when to re-initialize the static sets. */
4896 static int sigprocmask_count
= -1;
4898 /* Which signals are currently blocked (initially none). */
4899 static sigset_t current_mask
;
4901 /* Which signals are pending (initially none). */
4902 static sigset_t pending_signals
;
4904 /* Previous handlers to restore when the blocked signals are unblocked. */
4905 typedef void (*sighandler_t
)(int);
4906 static sighandler_t prev_handlers
[320];
4908 /* A signal handler which just records that a signal occured
4909 (it will be raised later, if and when the signal is unblocked). */
4911 sig_suspender (signo
)
4914 sigaddset (&pending_signals
, signo
);
4918 sigprocmask (how
, new_set
, old_set
)
4920 const sigset_t
*new_set
;
4926 /* If called for the first time, initialize. */
4927 if (sigprocmask_count
!= __bss_count
)
4929 sigprocmask_count
= __bss_count
;
4930 sigemptyset (&pending_signals
);
4931 sigemptyset (¤t_mask
);
4932 for (signo
= 0; signo
< 320; signo
++)
4933 prev_handlers
[signo
] = SIG_ERR
;
4937 *old_set
= current_mask
;
4942 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4948 sigemptyset (&new_mask
);
4950 /* DJGPP supports upto 320 signals. */
4951 for (signo
= 0; signo
< 320; signo
++)
4953 if (sigismember (¤t_mask
, signo
))
4954 sigaddset (&new_mask
, signo
);
4955 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4957 sigaddset (&new_mask
, signo
);
4959 /* SIGKILL is silently ignored, as on other platforms. */
4960 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4961 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
4963 if (( how
== SIG_UNBLOCK
4964 && sigismember (&new_mask
, signo
)
4965 && sigismember (new_set
, signo
))
4966 || (how
== SIG_SETMASK
4967 && sigismember (&new_mask
, signo
)
4968 && !sigismember (new_set
, signo
)))
4970 sigdelset (&new_mask
, signo
);
4971 if (prev_handlers
[signo
] != SIG_ERR
)
4973 signal (signo
, prev_handlers
[signo
]);
4974 prev_handlers
[signo
] = SIG_ERR
;
4976 if (sigismember (&pending_signals
, signo
))
4978 sigdelset (&pending_signals
, signo
);
4983 current_mask
= new_mask
;
4987 #else /* not POSIX_SIGNALS */
4989 sigsetmask (x
) int x
; { return 0; }
4990 sigblock (mask
) int mask
; { return 0; }
4992 #endif /* not POSIX_SIGNALS */
4993 #endif /* __DJGPP__ > 1 */
4996 #include "sysselect.h"
4998 #ifndef EMACS_TIME_ZERO_OR_NEG_P
4999 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5000 ((long)(time).tv_sec < 0 \
5001 || ((time).tv_sec == 0 \
5002 && (long)(time).tv_usec <= 0))
5005 /* This yields the rest of the current time slice to the task manager.
5006 It should be called by any code which knows that it has nothing
5007 useful to do except idle.
5009 I don't use __dpmi_yield here, since versions of library before 2.02
5010 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5011 on some versions of Windows 9X. */
5014 dos_yield_time_slice (void)
5016 _go32_dpmi_registers r
;
5019 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5020 _go32_dpmi_simulate_int (0x2f, &r
);
5025 /* Only event queue is checked. */
5026 /* We don't have to call timer_check here
5027 because wait_reading_process_input takes care of that. */
5029 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5031 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5032 EMACS_TIME
*timeout
;
5040 check_input
= FD_ISSET (0, rfds
);
5051 /* If we are looking only for the terminal, with no timeout,
5052 just read it and wait -- that's more efficient. */
5055 while (!detect_input_pending ())
5057 dos_yield_time_slice ();
5062 EMACS_TIME clnow
, cllast
, cldiff
;
5065 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5067 while (!check_input
|| !detect_input_pending ())
5070 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5071 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5073 /* When seconds wrap around, we assume that no more than
5074 1 minute passed since last `gettime'. */
5075 if (EMACS_TIME_NEG_P (cldiff
))
5076 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5077 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5079 /* Stop when timeout value crosses zero. */
5080 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5083 dos_yield_time_slice ();
5093 * Define overlaid functions:
5095 * chdir -> sys_chdir
5096 * tzset -> init_gettimeofday
5097 * abort -> dos_abort
5102 extern int chdir ();
5108 int len
= strlen (path
);
5109 char *tmp
= (char *)path
;
5111 if (*tmp
&& tmp
[1] == ':')
5113 if (getdisk () != tolower (tmp
[0]) - 'a')
5114 setdisk (tolower (tmp
[0]) - 'a');
5115 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5119 if (len
> 1 && (tmp
[len
- 1] == '/'))
5121 char *tmp1
= (char *) alloca (len
+ 1);
5132 extern void tzset (void);
5135 init_gettimeofday ()
5141 ltm
= gtm
= time (NULL
);
5142 ltm
= mktime (lstm
= localtime (<m
));
5143 gtm
= mktime (gmtime (>m
));
5144 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5145 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5146 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5153 dos_abort (file
, line
)
5157 char buffer1
[200], buffer2
[400];
5160 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5161 for (i
= j
= 0; buffer1
[i
]; i
++) {
5162 buffer2
[j
++] = buffer1
[i
];
5163 buffer2
[j
++] = 0x70;
5165 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5166 ScreenSetCursor (2, 0);
5174 ScreenSetCursor (10, 0);
5175 cputs ("\r\n\nEmacs aborted!\r\n");
5177 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5178 if (screen_virtual_segment
)
5179 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5180 /* Generate traceback, so we could tell whodunit. */
5181 signal (SIGINT
, SIG_DFL
);
5182 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5183 #else /* __DJGPP_MINOR__ >= 2 */
5185 #endif /* __DJGPP_MINOR__ >= 2 */
5191 /* The following variables are required so that cus-start.el won't
5192 complain about unbound variables. */
5193 #ifndef HAVE_X_WINDOWS
5194 /* Search path for bitmap files (xfns.c). */
5195 Lisp_Object Vx_bitmap_file_path
;
5196 int x_stretch_cursor_p
;
5198 #ifndef subprocesses
5199 /* Nonzero means delete a process right away if it exits (process.c). */
5200 static int delete_exited_processes
;
5205 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5206 staticpro (&recent_doskeys
);
5207 #ifndef HAVE_X_WINDOWS
5209 staticpro (&help_echo
);
5210 help_echo_object
= Qnil
;
5211 staticpro (&help_echo_object
);
5212 help_echo_window
= Qnil
;
5213 staticpro (&help_echo_window
);
5214 previous_help_echo
= Qnil
;
5215 staticpro (&previous_help_echo
);
5218 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5219 "List of directories to search for bitmap files for X.");
5220 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5222 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5223 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5224 For example, if a block cursor is over a tab, it will be drawn as\n\
5225 wide as that tab on the display. (No effect on MS-DOS.)");
5226 x_stretch_cursor_p
= 0;
5228 /* The following three are from xfns.c: */
5229 Qbackground_color
= intern ("background-color");
5230 staticpro (&Qbackground_color
);
5231 Qforeground_color
= intern ("foreground-color");
5232 staticpro (&Qforeground_color
);
5233 Qbar
= intern ("bar");
5235 Qcursor_type
= intern ("cursor-type");
5236 staticpro (&Qcursor_type
);
5237 Qreverse
= intern ("reverse");
5238 staticpro (&Qreverse
);
5240 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5241 "*Glyph to display instead of chars not supported by current codepage.\n\
5243 This variable is used only by MSDOS terminals.");
5244 Vdos_unsupported_char_glyph
= '\177';
5246 #ifndef subprocesses
5247 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5248 "*Non-nil means delete processes immediately when they exit.\n\
5249 nil means don't delete them until `list-processes' is run.");
5250 delete_exited_processes
= 0;
5253 defsubr (&Srecent_doskeys
);
5254 defsubr (&Smsdos_long_file_names
);
5255 defsubr (&Smsdos_downcase_filename
);
5256 defsubr (&Smsdos_remember_default_colors
);
5257 defsubr (&Smsdos_set_mouse_buttons
);