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"
67 /* #include <process.h> */
68 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
76 #define _dos_ds _go32_info_block.selector_for_linear_memory
82 #include "syssignal.h"
88 /* If other `malloc' than ours is used, force our `sbrk' behave like
89 Unix programs expect (resize memory blocks to keep them contiguous).
90 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
91 because that's what `gmalloc' expects to get. */
95 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
96 #else /* not REL_ALLOC */
97 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
98 #endif /* not REL_ALLOC */
99 #endif /* GNU_MALLOC */
101 #endif /* not SYSTEM_MALLOC */
102 #endif /* __DJGPP__ > 1 */
121 /* ------------------------ Mouse control ---------------------------
123 * Coordinates are in screen positions and zero based.
124 * Mouse buttons are numbered from left to right and also zero based.
127 /* This used to be in termhooks.h, but mainstream Emacs code no longer
128 uses it, and it was removed... */
129 #define NUM_MOUSE_BUTTONS (5)
131 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
132 static int mouse_visible
;
134 static int mouse_last_x
;
135 static int mouse_last_y
;
137 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
138 static int mouse_button_count
;
145 if (have_mouse
> 0 && !mouse_visible
)
148 fprintf (termscript
, "<M_ON>");
150 int86 (0x33, ®s
, ®s
);
160 if (have_mouse
> 0 && mouse_visible
)
163 fprintf (termscript
, "<M_OFF>");
165 int86 (0x33, ®s
, ®s
);
171 mouse_setup_buttons (int n_buttons
)
175 mouse_button_count
= 3;
176 mouse_button_translate
[0] = 0; /* Left */
177 mouse_button_translate
[1] = 2; /* Middle */
178 mouse_button_translate
[2] = 1; /* Right */
180 else /* two, what else? */
182 mouse_button_count
= 2;
183 mouse_button_translate
[0] = 0;
184 mouse_button_translate
[1] = 1;
188 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
189 1, 1, "NSet number of mouse buttons to: ",
190 "Set the number of mouse buttons to use by Emacs.\n
191 This is useful with mice that report the number of buttons inconsistently,\n
192 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of\n
193 them. This happens with wheeled mice on Windows 9X, for example.")
195 Lisp_Object nbuttons
;
197 CHECK_NUMBER (nbuttons
, 0);
198 mouse_setup_buttons (XINT (nbuttons
));
203 mouse_get_xy (int *x
, int *y
)
208 int86 (0x33, ®s
, ®s
);
220 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
222 mouse_last_x
= regs
.x
.cx
= x
* 8;
223 mouse_last_y
= regs
.x
.dx
= y
* 8;
224 int86 (0x33, ®s
, ®s
);
228 mouse_pressed (b
, xp
, yp
)
233 if (b
>= mouse_button_count
)
236 regs
.x
.bx
= mouse_button_translate
[b
];
237 int86 (0x33, ®s
, ®s
);
239 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
240 return (regs
.x
.bx
!= 0);
244 mouse_released (b
, xp
, yp
)
249 if (b
>= mouse_button_count
)
252 regs
.x
.bx
= mouse_button_translate
[b
];
253 int86 (0x33, ®s
, ®s
);
255 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
256 return (regs
.x
.bx
!= 0);
260 mouse_button_depressed (b
, xp
, yp
)
265 if (b
>= mouse_button_count
)
268 int86 (0x33, ®s
, ®s
);
269 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
279 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
282 Lisp_Object
*bar_window
, *x
, *y
;
283 enum scroll_bar_part
*part
;
287 Lisp_Object frame
, tail
;
289 /* Clear the mouse-moved flag for every frame on this display. */
290 FOR_EACH_FRAME (tail
, frame
)
291 XFRAME (frame
)->mouse_moved
= 0;
293 *f
= SELECTED_FRAME();
295 mouse_get_xy (&ix
, &iy
);
296 *time
= event_timestamp ();
297 *x
= make_number (mouse_last_x
= ix
);
298 *y
= make_number (mouse_last_y
= iy
);
306 mouse_get_xy (&x
, &y
);
307 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
319 fprintf (termscript
, "<M_INIT>");
322 int86 (0x33, ®s
, ®s
);
324 /* Reset the mouse last press/release info. It seems that Windows
325 doesn't do that automatically when function 21h is called, which
326 causes Emacs to ``remember'' the click that switched focus to the
327 window just before Emacs was started from that window. */
328 for (b
= 0; b
< mouse_button_count
; b
++)
330 int dummy_x
, dummy_y
;
332 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
333 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
338 regs
.x
.dx
= 8 * (ScreenCols () - 1);
339 int86 (0x33, ®s
, ®s
);
343 regs
.x
.dx
= 8 * (ScreenRows () - 1);
344 int86 (0x33, ®s
, ®s
);
350 /* ------------------------- Screen control ----------------------
354 static int internal_terminal
= 0;
356 #ifndef HAVE_X_WINDOWS
357 extern unsigned char ScreenAttrib
;
358 static int screen_face
;
359 static int highlight
;
361 static int screen_size_X
;
362 static int screen_size_Y
;
363 static int screen_size
;
365 static int current_pos_X
;
366 static int current_pos_Y
;
367 static int new_pos_X
;
368 static int new_pos_Y
;
370 static void *startup_screen_buffer
;
371 static int startup_screen_size_X
;
372 static int startup_screen_size_Y
;
373 static int startup_pos_X
;
374 static int startup_pos_Y
;
375 static unsigned char startup_screen_attrib
;
377 static clock_t startup_time
;
379 static int term_setup_done
;
381 static unsigned short outside_cursor
;
383 /* Similar to the_only_frame. */
384 struct x_output the_only_x_display
;
386 /* Support for DOS/V (allows Japanese characters to be displayed on
387 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
389 /* Holds the address of the text-mode screen buffer. */
390 static unsigned long screen_old_address
= 0;
391 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
392 static unsigned short screen_virtual_segment
= 0;
393 static unsigned short screen_virtual_offset
= 0;
394 /* A flag to control how to display unibyte 8-bit characters. */
395 extern int unibyte_display_via_language_environment
;
400 /* Update the screen from a part of relocated DOS/V screen buffer which
401 begins at OFFSET and includes COUNT characters. */
403 dosv_refresh_virtual_screen (int offset
, int count
)
407 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
410 regs
.h
.ah
= 0xff; /* update relocated screen */
411 regs
.x
.es
= screen_virtual_segment
;
412 regs
.x
.di
= screen_virtual_offset
+ offset
;
414 __dpmi_int (0x10, ®s
);
419 dos_direct_output (y
, x
, buf
, len
)
425 int t0
= 2 * (x
+ y
* screen_size_X
);
426 int t
= t0
+ (int) ScreenPrimary
;
431 dosmemput (buf
++, 1, t
);
435 /* This is faster. */
436 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
437 _farnspokeb (t
, *buf
);
439 if (screen_virtual_segment
)
440 dosv_refresh_virtual_screen (t0
, l0
);
445 /* Flash the screen as a substitute for BEEPs. */
449 do_visible_bell (xorattr
)
450 unsigned char xorattr
;
455 movl _ScreenPrimary,%%eax
462 xorb %%al,%%gs:(%%ebx)
478 : "m" (xorattr
), "g" (screen_size
)
479 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
483 ScreenVisualBell (void)
485 /* This creates an xor-mask that will swap the default fore- and
486 background colors. */
487 do_visible_bell (((the_only_x_display
.foreground_pixel
488 ^ the_only_x_display
.background_pixel
)
493 #ifndef HAVE_X_WINDOWS
495 static int blink_bit
= -1; /* the state of the blink bit at startup */
497 /* Enable bright background colors. */
503 /* Remember the original state of the blink/bright-background bit.
504 It is stored at 0040:0065h in the BIOS data area. */
506 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
510 int86 (0x10, ®s
, ®s
);
513 /* Disable bright background colors (and enable blinking) if we found
514 the video system in that state at startup. */
516 maybe_enable_blinking (void)
524 int86 (0x10, ®s
, ®s
);
528 /* Return non-zero if the system has a VGA adapter. */
535 int86 (0x10, ®s
, ®s
);
536 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
541 /* Set the screen dimensions so that it can show no less than
542 ROWS x COLS frame. */
545 dos_set_window_size (rows
, cols
)
549 Lisp_Object video_mode
;
550 int video_mode_value
;
553 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
555 if (*rows
== current_rows
&& *cols
== current_cols
)
559 have_vga
= vga_installed ();
561 /* If the user specified a special video mode for these dimensions,
563 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
564 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
567 if (INTEGERP (video_mode
)
568 && (video_mode_value
= XINT (video_mode
)) > 0)
570 regs
.x
.ax
= video_mode_value
;
571 int86 (0x10, ®s
, ®s
);
575 /* Must hardware-reset the mouse, or else it won't update
576 its notion of screen dimensions for some non-standard
577 video modes. This is *painfully* slow... */
579 int86 (0x33, ®s
, ®s
);
583 /* Find one of the dimensions supported by standard EGA/VGA
584 which gives us at least the required dimensions. */
593 } std_dimension
[] = {
603 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
605 if (std_dimension
[i
].need_vga
<= have_vga
606 && std_dimension
[i
].rows
>= *rows
)
608 if (std_dimension
[i
].rows
!= current_rows
609 || *cols
!= current_cols
)
610 _set_screen_lines (std_dimension
[i
].rows
);
617 #else /* not __DJGPP__ > 1 */
619 else if (*rows
<= 25)
621 if (current_rows
!= 25 || current_cols
!= 80)
624 int86 (0x10, ®s
, ®s
);
627 int86 (0x10, ®s
, ®s
);
630 int86 (0x10, ®s
, ®s
);
632 int86 (0x10, ®s
, ®s
);
635 else if (*rows
<= 50)
636 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
637 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
640 int86 (0x10, ®s
, ®s
);
643 int86 (0x10, ®s
, ®s
);
646 int86 (0x10, ®s
, ®s
);
649 int86 (0x10, ®s
, ®s
);
651 #endif /* not __DJGPP__ > 1 */
659 /* Tell the caller what dimensions have been REALLY set. */
660 *rows
= ScreenRows ();
661 *cols
= ScreenCols ();
664 /* If the dimensions changed, the mouse highlight info is invalid. */
665 if (current_rows
!= *rows
|| current_cols
!= *cols
)
667 struct frame
*f
= SELECTED_FRAME();
668 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
669 Lisp_Object window
= dpyinfo
->mouse_face_window
;
671 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
673 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
674 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
675 dpyinfo
->mouse_face_window
= Qnil
;
680 /* Enable bright background colors. */
683 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
684 be defensive anyway. */
685 if (screen_virtual_segment
)
686 dosv_refresh_virtual_screen (0, *cols
* *rows
);
689 /* If we write a character in the position where the mouse is,
690 the mouse cursor may need to be refreshed. */
700 mouse_get_xy (&x
, &y
);
701 if (y
!= new_pos_Y
|| x
< new_pos_X
)
707 #define DEFAULT_CURSOR_START (-1)
708 #define DEFAULT_CURSOR_WIDTH (-1)
709 #define BOX_CURSOR_WIDTH (-32)
711 /* Set cursor to begin at scan line START_LINE in the character cell
712 and extend for WIDTH scan lines. Scan lines are counted from top
713 of the character cell, starting from zero. */
715 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
718 unsigned desired_cursor
;
720 int max_line
, top_line
, bot_line
;
722 /* Avoid the costly BIOS call if F isn't the currently selected
723 frame. Allow for NULL as unconditionally meaning the selected
725 if (f
&& f
!= SELECTED_FRAME())
728 /* The character cell size in scan lines is stored at 40:85 in the
730 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
733 default: /* this relies on CGA cursor emulation being ON! */
750 if (width
== BOX_CURSOR_WIDTH
)
755 else if (start_line
!= DEFAULT_CURSOR_START
)
757 top_line
= start_line
;
758 bot_line
= top_line
- width
- 1;
760 else if (width
!= DEFAULT_CURSOR_WIDTH
)
763 bot_line
= -1 - width
;
766 top_line
= bot_line
+ 1;
770 /* [31, 0] seems to DTRT for all screen sizes. */
774 else /* WIDTH is positive */
776 if (start_line
!= DEFAULT_CURSOR_START
)
777 bot_line
= start_line
;
778 top_line
= bot_line
- (width
- 1);
781 /* If the current cursor shape is already what they want, we are
783 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
784 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
788 regs
.x
.cx
= desired_cursor
;
789 __dpmi_int (0x10, ®s
);
790 #endif /* __DJGPP__ > 1 */
794 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
796 if (EQ (cursor_type
, Qbar
))
798 /* Just BAR means the normal EGA/VGA cursor. */
799 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
801 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
803 Lisp_Object bar_parms
= XCDR (cursor_type
);
806 if (INTEGERP (bar_parms
))
808 /* Feature: negative WIDTH means cursor at the top
809 of the character cell, zero means invisible cursor. */
810 width
= XINT (bar_parms
);
811 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
814 else if (CONSP (bar_parms
)
815 && INTEGERP (XCAR (bar_parms
))
816 && INTEGERP (XCDR (bar_parms
)))
818 int start_line
= XINT (XCDR (bar_parms
));
820 width
= XINT (XCAR (bar_parms
));
821 msdos_set_cursor_shape (f
, start_line
, width
);
825 /* Treat anything unknown as "box cursor". This includes nil, so
826 that a frame which doesn't specify a cursor type gets a box,
827 which is the default in Emacs. */
828 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
841 union REGS inregs
, outregs
;
844 intdos (&inregs
, &outregs
);
848 /* Given a face id FACE, extract the face parameters to be used for
849 display until the face changes. The face parameters (actually, its
850 color) are used to construct the video attribute byte for each
851 glyph during the construction of the buffer that is then blitted to
854 IT_set_face (int face
)
856 struct frame
*sf
= SELECTED_FRAME();
857 struct face
*fp
= FACE_FROM_ID (sf
, face
);
858 unsigned long fg
, bg
;
862 fp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
863 /* The default face for the frame should always be realized and
872 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
873 colors mean use the colors of the default face, except that if
874 highlight is on, invert the foreground and the background. Note
875 that we assume all 16 colors to be available for the background,
876 since Emacs switches on this mode (and loses the blinking
877 attribute) at startup. */
878 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
879 fg
= FRAME_FOREGROUND_PIXEL (sf
);
880 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
881 fg
= FRAME_BACKGROUND_PIXEL (sf
);
882 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
883 bg
= FRAME_BACKGROUND_PIXEL (sf
);
884 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
885 bg
= FRAME_FOREGROUND_PIXEL (sf
);
887 /* Make sure highlighted lines really stand out, come what may. */
888 if ((highlight
|| fp
->tty_reverse_p
)
889 && (fg
== FRAME_FOREGROUND_PIXEL (sf
)
890 && bg
== FRAME_BACKGROUND_PIXEL (sf
)))
892 unsigned long tem
= fg
;
898 fprintf (termscript
, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face
,
899 highlight
? "H" : "", fp
->foreground
, fp
->background
, fg
, bg
);
900 if (fg
>= 0 && fg
< 16)
902 ScreenAttrib
&= 0xf0;
905 if (bg
>= 0 && bg
< 16)
907 ScreenAttrib
&= 0x0f;
908 ScreenAttrib
|= ((bg
& 0x0f) << 4);
912 Lisp_Object Vdos_unsupported_char_glyph
;
915 IT_write_glyphs (struct glyph
*str
, int str_len
)
917 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
918 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
919 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
920 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
921 register int sl
= str_len
;
922 register int tlen
= GLYPH_TABLE_LENGTH
;
923 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
925 /* If terminal_coding does any conversion, use it, otherwise use
926 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
927 because it always returns 1 if terminal_coding.src_multibyte is 1. */
928 struct coding_system
*coding
=
929 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
931 : &safe_terminal_coding
);
934 /* Do we need to consider conversion of unibyte characters to
936 int convert_unibyte_characters
937 = (NILP (current_buffer
->enable_multibyte_characters
)
938 && unibyte_display_via_language_environment
);
940 if (str_len
<= 0) return;
942 screen_buf
= screen_bp
= alloca (str_len
* 2);
943 screen_buf_end
= screen_buf
+ str_len
* 2;
944 sf
= SELECTED_FRAME();
946 /* Since faces get cached and uncached behind our back, we can't
947 rely on their indices in the cache being consistent across
948 invocations. So always reset the screen face to the default
949 face of the frame, before writing glyphs, and let the glyphs
950 set the right face if it's different from the default. */
951 IT_set_face (DEFAULT_FACE_ID
);
953 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
955 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
958 int cf
, chlen
, enclen
;
959 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
962 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
963 only for the redisplay code to know how many columns does
964 this character occupy on the screen. Skip padding glyphs. */
965 if (CHAR_GLYPH_PADDING_P (*str
))
972 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
973 int glyph_not_in_table
= 0;
975 if (g
< 0 || g
>= tlen
)
977 /* This glyph doesn't have an entry in Vglyph_table. */
979 glyph_not_in_table
= 1;
983 /* This glyph has an entry in Vglyph_table, so process
984 any aliases before testing for simpleness. */
985 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
986 ch
= FAST_GLYPH_CHAR (g
);
989 /* Convert the character code to multibyte, if they
990 requested display via language environment. We only want
991 to convert unibyte characters to multibyte in unibyte
992 buffers! Otherwise, the 8-bit value in CH came from the
993 display table set up to display foreign characters. */
994 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
996 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
997 ch
= unibyte_char_to_multibyte (ch
);
999 /* Invalid characters are displayed with a special glyph. */
1000 if (! CHAR_VALID_P (ch
, 0))
1002 g
= !NILP (Vdos_unsupported_char_glyph
)
1003 ? Vdos_unsupported_char_glyph
1004 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1005 ch
= FAST_GLYPH_CHAR (g
);
1008 /* If the face of this glyph is different from the current
1009 screen face, update the screen attribute byte. */
1010 cf
= FAST_GLYPH_FACE (g
);
1011 if (cf
!= screen_face
)
1012 IT_set_face (cf
); /* handles invalid faces gracefully */
1014 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1016 /* We generate the multi-byte form of CH in WORKBUF. */
1017 chlen
= CHAR_STRING (ch
, workbuf
);
1022 /* We have a string in Vglyph_table. */
1023 chlen
= GLYPH_LENGTH (tbase
, g
);
1024 buf
= GLYPH_STRING (tbase
, g
);
1027 /* If the character is not multibyte, don't bother converting it. */
1030 *conversion_buffer
= (unsigned char)ch
;
1036 coding
->src_multibyte
= 1;
1037 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1038 conversion_buffer_size
);
1039 chlen
-= coding
->consumed
;
1040 enclen
= coding
->produced
;
1042 /* Replace glyph codes that cannot be converted by
1043 terminal_coding with Vdos_unsupported_char_glyph. */
1044 if (*conversion_buffer
== '?')
1046 char *cbp
= conversion_buffer
;
1048 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1049 *cbp
++ = unsupported_char
;
1050 if (unsupported_face
!= screen_face
)
1051 IT_set_face (unsupported_face
);
1055 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1057 /* The allocated buffer for screen writes is too small.
1058 Flush it and loop again without incrementing STR, so
1059 that the next loop will begin with the same glyph. */
1060 int nbytes
= screen_bp
- screen_buf
;
1063 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1064 if (screen_virtual_segment
)
1065 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1066 new_pos_X
+= nbytes
/ 2;
1069 /* Prepare to reuse the same buffer again. */
1070 screen_bp
= screen_buf
;
1074 /* There's enough place in the allocated buffer to add
1075 the encoding of this glyph. */
1077 /* First, copy the encoded bytes. */
1078 for (bp
= conversion_buffer
; enclen
--; bp
++)
1080 *screen_bp
++ = (unsigned char)*bp
;
1081 *screen_bp
++ = ScreenAttrib
;
1083 fputc (*bp
, termscript
);
1086 /* Now copy the bytes not consumed by the encoding. */
1089 buf
+= coding
->consumed
;
1093 fputc (*buf
, termscript
);
1094 *screen_bp
++ = (unsigned char)*buf
++;
1095 *screen_bp
++ = ScreenAttrib
;
1099 /* Update STR and its remaining length. */
1106 /* Dump whatever is left in the screen buffer. */
1108 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1109 if (screen_virtual_segment
)
1110 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1111 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1113 /* We may have to output some codes to terminate the writing. */
1114 if (CODING_REQUIRE_FLUSHING (coding
))
1116 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1117 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1118 if (coding
->produced
> 0)
1120 screen_buf
= alloca (coding
->produced
* 2);
1121 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1122 coding
->produced
--; bp
++)
1124 *screen_bp
++ = (unsigned char)*bp
;
1125 *screen_bp
++ = ScreenAttrib
;
1127 fputc (*bp
, termscript
);
1129 offset
+= screen_bp
- screen_buf
;
1131 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1132 (int)ScreenPrimary
+ offset
);
1133 if (screen_virtual_segment
)
1134 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1135 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1140 /************************************************************************
1141 Mouse Highlight (and friends..)
1142 ************************************************************************/
1144 /* This is used for debugging, to turn off note_mouse_highlight. */
1145 int disable_mouse_highlight
;
1147 /* If non-nil, dos_rawgetc generates an event to display that string.
1148 (The display is done in keyboard.c:read_char, by calling
1150 static Lisp_Object help_echo
;
1151 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1153 /* These record the window, the object and the position where the help
1154 echo string was generated. */
1155 static Lisp_Object help_echo_window
;
1156 static Lisp_Object help_echo_object
;
1157 static int help_echo_pos
;
1159 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1161 /* Set the mouse pointer shape according to whether it is in the
1162 area where the mouse highlight is in effect. */
1164 IT_set_mouse_pointer (int mode
)
1166 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1167 many possibilities to change its shape, and the available
1168 functionality pretty much sucks (e.g., almost every reasonable
1169 shape will conceal the character it is on). Since the color of
1170 the pointer changes in the highlighted area, it is not clear to
1171 me whether anything else is required, anyway. */
1174 /* Display the active region described by mouse_face_*
1175 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1177 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1179 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1180 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1185 /* If window is in the process of being destroyed, don't bother
1187 if (w
->current_matrix
== NULL
)
1188 goto set_cursor_shape
;
1190 /* Recognize when we are called to operate on rows that don't exist
1191 anymore. This can happen when a window is split. */
1192 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1193 goto set_cursor_shape
;
1195 /* There's no sense to do anything if the mouse face isn't realized. */
1198 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1200 goto set_cursor_shape
;
1203 /* Note that mouse_face_beg_row etc. are window relative. */
1204 for (i
= dpyinfo
->mouse_face_beg_row
;
1205 i
<= dpyinfo
->mouse_face_end_row
;
1208 int start_hpos
, end_hpos
;
1209 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1211 /* Don't do anything if row doesn't have valid contents. */
1212 if (!row
->enabled_p
)
1215 /* For all but the first row, the highlight starts at column 0. */
1216 if (i
== dpyinfo
->mouse_face_beg_row
)
1217 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1221 if (i
== dpyinfo
->mouse_face_end_row
)
1222 end_hpos
= dpyinfo
->mouse_face_end_col
;
1224 end_hpos
= row
->used
[TEXT_AREA
];
1226 if (end_hpos
<= start_hpos
)
1228 /* Record that some glyphs of this row are displayed in
1230 row
->mouse_face_p
= hl
> 0;
1233 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1234 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1235 int nglyphs
= end_hpos
- start_hpos
;
1236 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1237 int start_offset
= offset
;
1240 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1241 kstart
, kstart
+ nglyphs
- 1, vpos
);
1244 IT_set_face (dpyinfo
->mouse_face_face_id
);
1245 /* Since we are going to change only the _colors_ of the
1246 displayed text, there's no need to go through all the
1247 pain of generating and encoding the text from the glyphs.
1248 Instead, we simply poke the attribute byte of each
1249 affected position in video memory with the colors
1250 computed by IT_set_face! */
1251 _farsetsel (_dos_ds
);
1254 _farnspokeb (offset
, ScreenAttrib
);
1257 if (screen_virtual_segment
)
1258 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1263 /* We are removing a previously-drawn mouse highlight. The
1264 safest way to do so is to redraw the glyphs anew, since
1265 all kinds of faces and display tables could have changed
1267 int nglyphs
= end_hpos
- start_hpos
;
1268 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1270 if (end_hpos
>= row
->used
[TEXT_AREA
])
1271 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1273 /* IT_write_glyphs writes at cursor position, so we need to
1274 temporarily move cursor coordinates to the beginning of
1275 the highlight region. */
1276 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1277 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1280 fprintf (termscript
, "<MH- %d-%d:%d>",
1281 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1282 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1284 fputs ("\n", termscript
);
1292 /* Change the mouse pointer shape. */
1293 IT_set_mouse_pointer (hl
);
1296 /* Clear out the mouse-highlighted active region.
1297 Redraw it un-highlighted first. */
1299 clear_mouse_face (struct display_info
*dpyinfo
)
1301 if (! NILP (dpyinfo
->mouse_face_window
))
1302 show_mouse_face (dpyinfo
, 0);
1304 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1305 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1306 dpyinfo
->mouse_face_window
= Qnil
;
1309 /* Find the glyph matrix position of buffer position POS in window W.
1310 *HPOS and *VPOS are set to the positions found. W's current glyphs
1311 must be up to date. If POS is above window start return (0, 0).
1312 If POS is after end of W, return end of last line in W. */
1314 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1318 int maybe_next_line_p
= 0;
1319 int line_start_position
;
1320 int yb
= window_text_bottom_y (w
);
1321 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1322 struct glyph_row
*best_row
= row
;
1326 if (row
->used
[TEXT_AREA
])
1327 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1329 line_start_position
= 0;
1331 if (line_start_position
> pos
)
1333 /* If the position sought is the end of the buffer,
1334 don't include the blank lines at the bottom of the window. */
1335 else if (line_start_position
== pos
1336 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1338 maybe_next_line_p
= 1;
1341 else if (line_start_position
> 0)
1347 /* Find the right column within BEST_ROW. */
1350 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1352 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1355 charpos
= glyph
->charpos
;
1362 else if (charpos
> pos
)
1364 else if (charpos
> 0)
1368 /* If we're looking for the end of the buffer,
1369 and we didn't find it in the line we scanned,
1370 use the start of the following line. */
1371 if (maybe_next_line_p
)
1378 *hpos
= lastcol
+ 1;
1382 /* Take proper action when mouse has moved to the mode or top line of
1383 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1384 mode line. X is relative to the start of the text display area of
1385 W, so the width of bitmap areas and scroll bars must be subtracted
1386 to get a position relative to the start of the mode line. */
1388 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1390 struct frame
*f
= XFRAME (w
->frame
);
1391 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1392 struct glyph_row
*row
;
1395 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1397 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1401 extern Lisp_Object Qhelp_echo
;
1402 struct glyph
*glyph
, *end
;
1403 Lisp_Object help
, map
;
1405 /* Find the glyph under X. */
1406 glyph
= row
->glyphs
[TEXT_AREA
]
1407 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1408 end
= glyph
+ row
->used
[TEXT_AREA
];
1410 && STRINGP (glyph
->object
)
1411 && XSTRING (glyph
->object
)->intervals
1412 && glyph
->charpos
>= 0
1413 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1415 /* If we're on a string with `help-echo' text property,
1416 arrange for the help to be displayed. This is done by
1417 setting the global variable help_echo to the help string. */
1418 help
= Fget_text_property (make_number (glyph
->charpos
),
1419 Qhelp_echo
, glyph
->object
);
1423 XSETWINDOW (help_echo_window
, w
);
1424 help_echo_object
= glyph
->object
;
1425 help_echo_pos
= glyph
->charpos
;
1431 /* Take proper action when the mouse has moved to position X, Y on
1432 frame F as regards highlighting characters that have mouse-face
1433 properties. Also de-highlighting chars where the mouse was before.
1434 X and Y can be negative or out of range. */
1436 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1438 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1443 /* When a menu is active, don't highlight because this looks odd. */
1444 if (mouse_preempted
)
1447 if (disable_mouse_highlight
1448 || !f
->glyphs_initialized_p
)
1451 dpyinfo
->mouse_face_mouse_x
= x
;
1452 dpyinfo
->mouse_face_mouse_y
= y
;
1453 dpyinfo
->mouse_face_mouse_frame
= f
;
1455 if (dpyinfo
->mouse_face_defer
)
1460 dpyinfo
->mouse_face_deferred_gc
= 1;
1464 /* Which window is that in? */
1465 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1467 /* If we were displaying active text in another window, clear that. */
1468 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1469 clear_mouse_face (dpyinfo
);
1471 /* Not on a window -> return. */
1472 if (!WINDOWP (window
))
1475 /* Convert to window-relative coordinates. */
1476 w
= XWINDOW (window
);
1477 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1478 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1480 if (portion
== 1 || portion
== 3)
1482 /* Mouse is on the mode or top line. */
1483 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1487 IT_set_mouse_pointer (0);
1489 /* Are we in a window whose display is up to date?
1490 And verify the buffer's text has not changed. */
1491 if (/* Within text portion of the window. */
1493 && EQ (w
->window_end_valid
, w
->buffer
)
1494 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1495 && (XFASTINT (w
->last_overlay_modified
)
1496 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1499 struct glyph_row
*row
;
1500 struct glyph
*glyph
;
1502 /* Find the glyph under X/Y. */
1504 if (y
< w
->current_matrix
->nrows
)
1506 row
= MATRIX_ROW (w
->current_matrix
, y
);
1508 && row
->displays_text_p
1509 && x
< window_box_width (w
, TEXT_AREA
))
1511 glyph
= row
->glyphs
[TEXT_AREA
];
1512 if (x
>= row
->used
[TEXT_AREA
])
1517 if (!BUFFERP (glyph
->object
))
1523 /* Clear mouse face if X/Y not over text. */
1526 clear_mouse_face (dpyinfo
);
1530 if (!BUFFERP (glyph
->object
))
1532 pos
= glyph
->charpos
;
1534 /* Check for mouse-face and help-echo. */
1536 extern Lisp_Object Qmouse_face
;
1537 Lisp_Object mouse_face
, overlay
, position
;
1538 Lisp_Object
*overlay_vec
;
1540 struct buffer
*obuf
;
1543 /* If we get an out-of-range value, return now; avoid an error. */
1544 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1547 /* Make the window's buffer temporarily current for
1548 overlays_at and compute_char_face. */
1549 obuf
= current_buffer
;
1550 current_buffer
= XBUFFER (w
->buffer
);
1556 /* Is this char mouse-active or does it have help-echo? */
1557 XSETINT (position
, pos
);
1559 /* Put all the overlays we want in a vector in overlay_vec.
1560 Store the length in len. If there are more than 10, make
1561 enough space for all, and try again. */
1563 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1564 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1565 if (noverlays
> len
)
1568 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1569 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1572 /* Sort overlays into increasing priority order. */
1573 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1575 /* Check mouse-face highlighting. */
1576 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1577 && y
>= dpyinfo
->mouse_face_beg_row
1578 && y
<= dpyinfo
->mouse_face_end_row
1579 && (y
> dpyinfo
->mouse_face_beg_row
1580 || x
>= dpyinfo
->mouse_face_beg_col
)
1581 && (y
< dpyinfo
->mouse_face_end_row
1582 || x
< dpyinfo
->mouse_face_end_col
1583 || dpyinfo
->mouse_face_past_end
)))
1585 /* Clear the display of the old active region, if any. */
1586 clear_mouse_face (dpyinfo
);
1588 /* Find highest priority overlay that has a mouse-face prop. */
1590 for (i
= noverlays
- 1; i
>= 0; --i
)
1592 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1593 if (!NILP (mouse_face
))
1595 overlay
= overlay_vec
[i
];
1600 /* If no overlay applies, get a text property. */
1602 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1605 /* Handle the overlay case. */
1606 if (! NILP (overlay
))
1608 /* Find the range of text around this char that
1609 should be active. */
1610 Lisp_Object before
, after
;
1613 before
= Foverlay_start (overlay
);
1614 after
= Foverlay_end (overlay
);
1615 /* Record this as the current active region. */
1616 fast_find_position (w
, XFASTINT (before
),
1617 &dpyinfo
->mouse_face_beg_col
,
1618 &dpyinfo
->mouse_face_beg_row
);
1619 dpyinfo
->mouse_face_past_end
1620 = !fast_find_position (w
, XFASTINT (after
),
1621 &dpyinfo
->mouse_face_end_col
,
1622 &dpyinfo
->mouse_face_end_row
);
1623 dpyinfo
->mouse_face_window
= window
;
1624 dpyinfo
->mouse_face_face_id
1625 = face_at_buffer_position (w
, pos
, 0, 0,
1626 &ignore
, pos
+ 1, 1);
1628 /* Display it as active. */
1629 show_mouse_face (dpyinfo
, 1);
1631 /* Handle the text property case. */
1632 else if (! NILP (mouse_face
))
1634 /* Find the range of text around this char that
1635 should be active. */
1636 Lisp_Object before
, after
, beginning
, end
;
1639 beginning
= Fmarker_position (w
->start
);
1640 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1641 - XFASTINT (w
->window_end_pos
)));
1643 = Fprevious_single_property_change (make_number (pos
+ 1),
1645 w
->buffer
, beginning
);
1647 = Fnext_single_property_change (position
, Qmouse_face
,
1649 /* Record this as the current active region. */
1650 fast_find_position (w
, XFASTINT (before
),
1651 &dpyinfo
->mouse_face_beg_col
,
1652 &dpyinfo
->mouse_face_beg_row
);
1653 dpyinfo
->mouse_face_past_end
1654 = !fast_find_position (w
, XFASTINT (after
),
1655 &dpyinfo
->mouse_face_end_col
,
1656 &dpyinfo
->mouse_face_end_row
);
1657 dpyinfo
->mouse_face_window
= window
;
1658 dpyinfo
->mouse_face_face_id
1659 = face_at_buffer_position (w
, pos
, 0, 0,
1660 &ignore
, pos
+ 1, 1);
1662 /* Display it as active. */
1663 show_mouse_face (dpyinfo
, 1);
1667 /* Look for a `help-echo' property. */
1670 extern Lisp_Object Qhelp_echo
;
1672 /* Check overlays first. */
1674 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1676 overlay
= overlay_vec
[i
];
1677 help
= Foverlay_get (overlay
, Qhelp_echo
);
1683 help_echo_window
= window
;
1684 help_echo_object
= overlay
;
1685 help_echo_pos
= pos
;
1687 /* Try text properties. */
1688 else if (NILP (help
)
1689 && ((STRINGP (glyph
->object
)
1690 && glyph
->charpos
>= 0
1691 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1692 || (BUFFERP (glyph
->object
)
1693 && glyph
->charpos
>= BEGV
1694 && glyph
->charpos
< ZV
)))
1696 help
= Fget_text_property (make_number (glyph
->charpos
),
1697 Qhelp_echo
, glyph
->object
);
1701 help_echo_window
= window
;
1702 help_echo_object
= glyph
->object
;
1703 help_echo_pos
= glyph
->charpos
;
1710 current_buffer
= obuf
;
1716 IT_clear_end_of_line (int first_unused
)
1720 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1721 extern int fatal_error_in_progress
;
1723 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1727 i
= (j
= first_unused
- new_pos_X
) * 2;
1729 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1730 spaces
= sp
= alloca (i
);
1735 *sp
++ = ScreenAttrib
;
1739 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1740 if (screen_virtual_segment
)
1741 dosv_refresh_virtual_screen (offset
, i
/ 2);
1743 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1744 Let's follow their lead, in case someone relies on this. */
1745 new_pos_X
= first_unused
;
1749 IT_clear_screen (void)
1752 fprintf (termscript
, "<CLR:SCR>");
1756 if (screen_virtual_segment
)
1757 dosv_refresh_virtual_screen (0, screen_size
);
1758 new_pos_X
= new_pos_Y
= 0;
1762 IT_clear_to_end (void)
1765 fprintf (termscript
, "<CLR:EOS>");
1767 while (new_pos_Y
< screen_size_Y
) {
1769 IT_clear_end_of_line (screen_size_X
);
1775 IT_cursor_to (int y
, int x
)
1778 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1783 static int cursor_cleared
;
1786 IT_display_cursor (int on
)
1788 if (on
&& cursor_cleared
)
1790 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1793 else if (!on
&& !cursor_cleared
)
1795 ScreenSetCursor (-1, -1);
1800 /* Emacs calls cursor-movement functions a lot when it updates the
1801 display (probably a legacy of old terminals where you cannot
1802 update a screen line without first moving the cursor there).
1803 However, cursor movement is expensive on MSDOS (it calls a slow
1804 BIOS function and requires 2 mode switches), while actual screen
1805 updates access the video memory directly and don't depend on
1806 cursor position. To avoid slowing down the redisplay, we cheat:
1807 all functions that move the cursor only set internal variables
1808 which record the cursor position, whereas the cursor is only
1809 moved to its final position whenever screen update is complete.
1811 `IT_cmgoto' is called from the keyboard reading loop and when the
1812 frame update is complete. This means that we are ready for user
1813 input, so we update the cursor position to show where the point is,
1814 and also make the mouse pointer visible.
1816 Special treatment is required when the cursor is in the echo area,
1817 to put the cursor at the end of the text displayed there. */
1820 IT_cmgoto (FRAME_PTR f
)
1822 /* Only set the cursor to where it should be if the display is
1823 already in sync with the window contents. */
1824 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1826 /* FIXME: This needs to be rewritten for the new redisplay, or
1829 static int previous_pos_X
= -1;
1831 update_cursor_pos
= 1; /* temporary!!! */
1833 /* If the display is in sync, forget any previous knowledge about
1834 cursor position. This is primarily for unexpected events like
1835 C-g in the minibuffer. */
1836 if (update_cursor_pos
&& previous_pos_X
>= 0)
1837 previous_pos_X
= -1;
1838 /* If we are in the echo area, put the cursor at the
1839 end of the echo area message. */
1840 if (!update_cursor_pos
1841 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1843 int tem_X
= current_pos_X
, dummy
;
1845 if (echo_area_glyphs
)
1847 tem_X
= echo_area_glyphs_length
;
1848 /* Save current cursor position, to be restored after the
1849 echo area message is erased. Only remember one level
1850 of previous cursor position. */
1851 if (previous_pos_X
== -1)
1852 ScreenGetCursor (&dummy
, &previous_pos_X
);
1854 else if (previous_pos_X
>= 0)
1856 /* We wind up here after the echo area message is erased.
1857 Restore the cursor position we remembered above. */
1858 tem_X
= previous_pos_X
;
1859 previous_pos_X
= -1;
1862 if (current_pos_X
!= tem_X
)
1865 update_cursor_pos
= 1;
1870 if (update_cursor_pos
1871 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1873 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1875 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1878 /* Maybe cursor is invisible, so make it visible. */
1879 IT_display_cursor (1);
1881 /* Mouse pointer should be always visible if we are waiting for
1888 IT_reassert_line_highlight (int new, int vpos
)
1894 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1896 highlight
= new_highlight
;
1897 IT_cursor_to (vpos
, 0);
1898 IT_clear_end_of_line (first_unused_hpos
);
1902 IT_update_begin (struct frame
*f
)
1904 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1910 if (f
== display_info
->mouse_face_mouse_frame
)
1912 /* Don't do highlighting for mouse motion during the update. */
1913 display_info
->mouse_face_defer
= 1;
1915 /* If F needs to be redrawn, simply forget about any prior mouse
1917 if (FRAME_GARBAGED_P (f
))
1918 display_info
->mouse_face_window
= Qnil
;
1920 /* Can we tell that this update does not affect the window
1921 where the mouse highlight is? If so, no need to turn off.
1922 Likewise, don't do anything if none of the enabled rows
1923 contains glyphs highlighted in mouse face. */
1924 if (!NILP (display_info
->mouse_face_window
)
1925 && WINDOWP (display_info
->mouse_face_window
))
1927 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1930 /* If the mouse highlight is in the window that was deleted
1931 (e.g., if it was popped by completion), clear highlight
1933 if (NILP (w
->buffer
))
1934 display_info
->mouse_face_window
= Qnil
;
1937 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1938 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1939 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1943 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1944 clear_mouse_face (display_info
);
1947 else if (!FRAME_LIVE_P (display_info
->mouse_face_mouse_frame
))
1949 /* If the frame with mouse highlight was deleted, invalidate the
1951 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1952 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1953 display_info
->mouse_face_window
= Qnil
;
1954 display_info
->mouse_face_deferred_gc
= 0;
1955 display_info
->mouse_face_mouse_frame
= NULL
;
1962 IT_update_end (struct frame
*f
)
1965 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1968 Lisp_Object Qcursor_type
;
1971 IT_frame_up_to_date (struct frame
*f
)
1973 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1974 Lisp_Object new_cursor
, frame_desired_cursor
;
1977 if (dpyinfo
->mouse_face_deferred_gc
1978 || f
== dpyinfo
->mouse_face_mouse_frame
)
1981 if (dpyinfo
->mouse_face_mouse_frame
)
1982 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1983 dpyinfo
->mouse_face_mouse_x
,
1984 dpyinfo
->mouse_face_mouse_y
);
1985 dpyinfo
->mouse_face_deferred_gc
= 0;
1989 /* Set the cursor type to whatever they wanted. In a minibuffer
1990 window, we want the cursor to appear only if we are reading input
1991 from this window, and we want the cursor to be taken from the
1992 frame parameters. For the selected window, we use either its
1993 buffer-local value or the value from the frame parameters if the
1994 buffer doesn't define its local value for the cursor type. */
1995 sw
= XWINDOW (f
->selected_window
);
1996 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
1997 if (cursor_in_echo_area
1998 && FRAME_HAS_MINIBUF_P (f
)
1999 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2000 && sw
== XWINDOW (echo_area_window
))
2001 new_cursor
= frame_desired_cursor
;
2004 struct buffer
*b
= XBUFFER (sw
->buffer
);
2006 if (EQ (b
->cursor_type
, Qt
))
2007 new_cursor
= frame_desired_cursor
;
2008 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2009 new_cursor
= Fcons (Qbar
, make_number (0));
2011 new_cursor
= b
->cursor_type
;
2014 IT_set_cursor_type (f
, new_cursor
);
2016 IT_cmgoto (f
); /* position cursor when update is done */
2019 /* Copy LEN glyphs displayed on a single line whose vertical position
2020 is YPOS, beginning at horizontal position XFROM to horizontal
2021 position XTO, by moving blocks in the video memory. Used by
2022 functions that insert and delete glyphs. */
2024 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2026 /* The offsets of source and destination relative to the
2027 conventional memorty selector. */
2028 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2029 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2031 if (from
== to
|| len
<= 0)
2034 _farsetsel (_dos_ds
);
2036 /* The source and destination might overlap, so we need to move
2037 glyphs non-destructively. */
2040 for ( ; len
; from
+= 2, to
+= 2, len
--)
2041 _farnspokew (to
, _farnspeekw (from
));
2045 from
+= (len
- 1) * 2;
2046 to
+= (len
- 1) * 2;
2047 for ( ; len
; from
-= 2, to
-= 2, len
--)
2048 _farnspokew (to
, _farnspeekw (from
));
2050 if (screen_virtual_segment
)
2051 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2054 /* Insert and delete glyphs. */
2056 IT_insert_glyphs (start
, len
)
2057 register struct glyph
*start
;
2060 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2062 /* Shift right the glyphs from the nominal cursor position to the
2063 end of this line. */
2064 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2066 /* Now write the glyphs to be inserted. */
2067 IT_write_glyphs (start
, len
);
2071 IT_delete_glyphs (n
)
2077 /* set-window-configuration on window.c needs this. */
2079 x_set_menu_bar_lines (f
, value
, oldval
)
2081 Lisp_Object value
, oldval
;
2083 set_menu_bar_lines (f
, value
, oldval
);
2086 /* This was copied from xfns.c */
2088 Lisp_Object Qbackground_color
;
2089 Lisp_Object Qforeground_color
;
2090 Lisp_Object Qreverse
;
2091 extern Lisp_Object Qtitle
;
2093 /* IT_set_terminal_modes is called when emacs is started,
2094 resumed, and whenever the screen is redrawn! */
2097 IT_set_terminal_modes (void)
2100 fprintf (termscript
, "\n<SET_TERM>");
2103 screen_size_X
= ScreenCols ();
2104 screen_size_Y
= ScreenRows ();
2105 screen_size
= screen_size_X
* screen_size_Y
;
2107 new_pos_X
= new_pos_Y
= 0;
2108 current_pos_X
= current_pos_Y
= -1;
2110 if (term_setup_done
)
2112 term_setup_done
= 1;
2114 startup_screen_size_X
= screen_size_X
;
2115 startup_screen_size_Y
= screen_size_Y
;
2116 startup_screen_attrib
= ScreenAttrib
;
2119 /* Is DOS/V (or any other RSIS software which relocates
2120 the screen) installed? */
2122 unsigned short es_value
;
2125 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2126 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2127 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2128 else if (screen_old_address
) /* already switched to Japanese mode once */
2129 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2131 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2133 es_value
= regs
.x
.es
;
2134 __dpmi_int (0x10, ®s
);
2136 if (regs
.x
.es
!= es_value
)
2138 /* screen_old_address is only set if ScreenPrimary does NOT
2139 already point to the relocated buffer address returned by
2140 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2141 ScreenPrimary to that address at startup under DOS/V. */
2142 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2143 screen_old_address
= ScreenPrimary
;
2144 screen_virtual_segment
= regs
.x
.es
;
2145 screen_virtual_offset
= regs
.x
.di
;
2146 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2149 #endif /* __DJGPP__ > 1 */
2151 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2152 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2155 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2156 screen_size_X
, screen_size_Y
);
2161 /* IT_reset_terminal_modes is called when emacs is
2162 suspended or killed. */
2165 IT_reset_terminal_modes (void)
2167 int display_row_start
= (int) ScreenPrimary
;
2168 int saved_row_len
= startup_screen_size_X
* 2;
2169 int update_row_len
= ScreenCols () * 2;
2170 int current_rows
= ScreenRows ();
2171 int to_next_row
= update_row_len
;
2172 unsigned char *saved_row
= startup_screen_buffer
;
2173 int cursor_pos_X
= ScreenCols () - 1;
2174 int cursor_pos_Y
= ScreenRows () - 1;
2177 fprintf (termscript
, "\n<RESET_TERM>");
2181 if (!term_setup_done
)
2186 /* Leave the video system in the same state as we found it,
2187 as far as the blink/bright-background bit is concerned. */
2188 maybe_enable_blinking ();
2190 /* We have a situation here.
2191 We cannot just do ScreenUpdate(startup_screen_buffer) because
2192 the luser could have changed screen dimensions inside Emacs
2193 and failed (or didn't want) to restore them before killing
2194 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2195 thus will happily use memory outside what was allocated for
2196 `startup_screen_buffer'.
2197 Thus we only restore as much as the current screen dimensions
2198 can hold, and clear the rest (if the saved screen is smaller than
2199 the current) with the color attribute saved at startup. The cursor
2200 is also restored within the visible dimensions. */
2202 ScreenAttrib
= startup_screen_attrib
;
2204 /* Don't restore the screen if we are exiting less than 2 seconds
2205 after startup: we might be crashing, and the screen might show
2206 some vital clues to what's wrong. */
2207 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2210 if (screen_virtual_segment
)
2211 dosv_refresh_virtual_screen (0, screen_size
);
2213 if (update_row_len
> saved_row_len
)
2214 update_row_len
= saved_row_len
;
2215 if (current_rows
> startup_screen_size_Y
)
2216 current_rows
= startup_screen_size_Y
;
2219 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2220 update_row_len
/ 2, current_rows
);
2222 while (current_rows
--)
2224 dosmemput (saved_row
, update_row_len
, display_row_start
);
2225 if (screen_virtual_segment
)
2226 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2227 update_row_len
/ 2);
2228 saved_row
+= saved_row_len
;
2229 display_row_start
+= to_next_row
;
2232 if (startup_pos_X
< cursor_pos_X
)
2233 cursor_pos_X
= startup_pos_X
;
2234 if (startup_pos_Y
< cursor_pos_Y
)
2235 cursor_pos_Y
= startup_pos_Y
;
2237 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2238 xfree (startup_screen_buffer
);
2240 term_setup_done
= 0;
2244 IT_set_terminal_window (int foo
)
2248 /* Remember the screen colors of the curent frame, to serve as the
2249 default colors for newly-created frames. */
2251 static int initial_screen_colors
[2];
2253 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2254 Smsdos_remember_default_colors
, 1, 1, 0,
2255 "Remember the screen colors of the current frame.")
2262 CHECK_FRAME (frame
, 0);
2264 reverse
= EQ (Fcdr (Fassq (intern ("reverse"), f
->param_alist
)), Qt
);
2266 initial_screen_colors
[0]
2267 = reverse
? FRAME_BACKGROUND_PIXEL (f
) : FRAME_FOREGROUND_PIXEL (f
);
2268 initial_screen_colors
[1]
2269 = reverse
? FRAME_FOREGROUND_PIXEL (f
) : FRAME_BACKGROUND_PIXEL (f
);
2273 IT_set_frame_parameters (f
, alist
)
2278 int length
= XINT (Flength (alist
));
2281 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2283 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2284 /* Do we have to reverse the foreground and background colors? */
2285 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2286 int was_reverse
= reverse
;
2287 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2288 unsigned long orig_fg
;
2289 unsigned long orig_bg
;
2291 /* If we are creating a new frame, begin with the original screen colors
2292 used for the initial frame. */
2293 if (alist
== Vdefault_frame_alist
2294 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2296 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2297 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2299 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2300 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2302 /* Extract parm names and values into those vectors. */
2304 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2309 parms
[i
] = Fcar (elt
);
2310 CHECK_SYMBOL (parms
[i
], 1);
2311 values
[i
] = Fcdr (elt
);
2317 for (i
= 0; i
< j
; i
++)
2319 Lisp_Object prop
= parms
[i
];
2320 Lisp_Object val
= values
[i
];
2322 if (EQ (prop
, Qreverse
))
2323 reverse
= EQ (val
, Qt
);
2326 if (termscript
&& reverse
&& !was_reverse
)
2327 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2329 /* Now process the alist elements in reverse of specified order. */
2330 for (i
--; i
>= 0; i
--)
2332 Lisp_Object prop
= parms
[i
];
2333 Lisp_Object val
= values
[i
];
2335 if (EQ (prop
, Qforeground_color
))
2337 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2338 ? LFACE_BACKGROUND_INDEX
2339 : LFACE_FOREGROUND_INDEX
);
2340 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2341 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2342 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2345 /* FIXME: should the fore-/background of the default
2346 face change here as well? */
2347 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2349 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2353 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2356 else if (EQ (prop
, Qbackground_color
))
2358 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2359 ? LFACE_FOREGROUND_INDEX
2360 : LFACE_BACKGROUND_INDEX
);
2361 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2362 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2363 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2366 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2368 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2372 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2375 else if (EQ (prop
, Qtitle
))
2377 x_set_title (f
, val
);
2379 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2381 else if (EQ (prop
, Qcursor_type
))
2383 IT_set_cursor_type (f
, val
);
2385 fprintf (termscript
, "<CTYPE: %s>\n",
2386 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2389 store_frame_param (f
, prop
, val
);
2392 /* If they specified "reverse", but not the colors, we need to swap
2393 the current frame colors. */
2394 if (reverse
&& !was_reverse
)
2398 FRAME_BACKGROUND_PIXEL (f
) = orig_fg
;
2403 FRAME_FOREGROUND_PIXEL (f
) = orig_bg
;
2410 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2411 if (f
== SELECTED_FRAME())
2416 extern void init_frame_faces (FRAME_PTR
);
2418 #endif /* !HAVE_X_WINDOWS */
2421 /* Do we need the internal terminal? */
2424 internal_terminal_init ()
2426 char *term
= getenv ("TERM");
2428 struct frame
*sf
= SELECTED_FRAME();
2430 #ifdef HAVE_X_WINDOWS
2431 if (!inhibit_window_system
)
2436 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2438 if (getenv ("EMACSTEST"))
2439 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2441 #ifndef HAVE_X_WINDOWS
2442 if (!internal_terminal
|| inhibit_window_system
)
2444 sf
->output_method
= output_termcap
;
2448 Vwindow_system
= intern ("pc");
2449 Vwindow_system_version
= make_number (1);
2450 sf
->output_method
= output_msdos_raw
;
2452 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2453 screen_old_address
= 0;
2455 /* Forget the stale screen colors as well. */
2456 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2458 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2459 the_only_x_display
.background_pixel
= 7; /* White */
2460 the_only_x_display
.foreground_pixel
= 0; /* Black */
2462 colors
= getenv ("EMACSCOLORS");
2463 if (colors
&& strlen (colors
) >= 2)
2465 /* The colors use 4 bits each (we enable bright background). */
2466 if (isdigit (colors
[0]))
2468 else if (isxdigit (colors
[0]))
2469 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2470 if (colors
[0] >= 0 && colors
[0] < 16)
2471 the_only_x_display
.foreground_pixel
= colors
[0];
2472 if (isdigit (colors
[1]))
2474 else if (isxdigit (colors
[1]))
2475 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2476 if (colors
[1] >= 0 && colors
[1] < 16)
2477 the_only_x_display
.background_pixel
= colors
[1];
2479 the_only_x_display
.line_height
= 1;
2480 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2481 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2482 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2483 the_only_x_display
.display_info
.mouse_face_beg_row
=
2484 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2485 the_only_x_display
.display_info
.mouse_face_end_row
=
2486 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2487 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2488 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2489 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2490 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2491 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2493 init_frame_faces (sf
);
2495 ring_bell_hook
= IT_ring_bell
;
2496 insert_glyphs_hook
= IT_insert_glyphs
;
2497 delete_glyphs_hook
= IT_delete_glyphs
;
2498 write_glyphs_hook
= IT_write_glyphs
;
2499 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2500 clear_to_end_hook
= IT_clear_to_end
;
2501 clear_end_of_line_hook
= IT_clear_end_of_line
;
2502 clear_frame_hook
= IT_clear_screen
;
2503 change_line_highlight_hook
= IT_change_line_highlight
;
2504 update_begin_hook
= IT_update_begin
;
2505 update_end_hook
= IT_update_end
;
2506 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2507 frame_up_to_date_hook
= IT_frame_up_to_date
;
2509 /* These hooks are called by term.c without being checked. */
2510 set_terminal_modes_hook
= IT_set_terminal_modes
;
2511 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2512 set_terminal_window_hook
= IT_set_terminal_window
;
2513 char_ins_del_ok
= 0;
2517 dos_get_saved_screen (screen
, rows
, cols
)
2522 #ifndef HAVE_X_WINDOWS
2523 *screen
= startup_screen_buffer
;
2524 *cols
= startup_screen_size_X
;
2525 *rows
= startup_screen_size_Y
;
2526 return *screen
!= (char *)0;
2532 #ifndef HAVE_X_WINDOWS
2534 /* We are not X, but we can emulate it well enough for our needs... */
2538 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2539 error ("Not running under a window system");
2545 /* ----------------------- Keyboard control ----------------------
2547 * Keymaps reflect the following keyboard layout:
2549 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2550 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2551 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2552 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2556 #define Ignore 0x0000
2557 #define Normal 0x0000 /* normal key - alt changes scan-code */
2558 #define FctKey 0x1000 /* func key if c == 0, else c */
2559 #define Special 0x2000 /* func key even if c != 0 */
2560 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2561 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2562 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2563 #define Grey 0x6000 /* Grey keypad key */
2565 #define Alt 0x0100 /* alt scan-code */
2566 #define Ctrl 0x0200 /* ctrl scan-code */
2567 #define Shift 0x0400 /* shift scan-code */
2569 static int extended_kbd
; /* 101 (102) keyboard present. */
2571 struct kbd_translate
{
2574 unsigned short code
;
2577 struct dos_keyboard_map
2582 struct kbd_translate
*translate_table
;
2586 static struct dos_keyboard_map us_keyboard
= {
2588 /* 01234567890123456789012345678901234567890 12345678901234 */
2589 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2590 /* 0123456789012345678901234567890123456789 012345678901234 */
2591 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2592 0, /* no Alt-Gr key */
2593 0 /* no translate table */
2596 static struct dos_keyboard_map fr_keyboard
= {
2598 /* 012 3456789012345678901234567890123456789012345678901234 */
2599 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2600 /* 0123456789012345678901234567890123456789012345678901234 */
2601 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2602 /* 01234567 89012345678901234567890123456789012345678901234 */
2604 0 /* no translate table */
2608 * Italian keyboard support, country code 39.
2611 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2612 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2615 static struct kbd_translate it_kbd_translate_table
[] = {
2616 { 0x56, 0x3c, Normal
| 13 },
2617 { 0x56, 0x3e, Normal
| 27 },
2620 static struct dos_keyboard_map it_keyboard
= {
2622 /* 0 123456789012345678901234567890123456789012345678901234 */
2623 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2624 /* 01 23456789012345678901234567890123456789012345678901234 */
2625 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2626 /* 0123456789012345678901234567890123456789012345678901234 */
2628 it_kbd_translate_table
2631 static struct dos_keyboard_map dk_keyboard
= {
2633 /* 0123456789012345678901234567890123456789012345678901234 */
2634 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2635 /* 01 23456789012345678901234567890123456789012345678901234 */
2636 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2637 /* 0123456789012345678901234567890123456789012345678901234 */
2639 0 /* no translate table */
2642 static struct kbd_translate jp_kbd_translate_table
[] = {
2643 { 0x73, 0x5c, Normal
| 0 },
2644 { 0x73, 0x5f, Normal
| 0 },
2645 { 0x73, 0x1c, Map
| 0 },
2646 { 0x7d, 0x5c, Normal
| 13 },
2647 { 0x7d, 0x7c, Normal
| 13 },
2648 { 0x7d, 0x1c, Map
| 13 },
2651 static struct dos_keyboard_map jp_keyboard
= {
2653 /* 0123456789012 345678901234567890123456789012345678901234 */
2654 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2655 /* 01 23456789012345678901234567890123456789012345678901234 */
2656 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2657 0, /* no Alt-Gr key */
2658 jp_kbd_translate_table
2661 static struct keyboard_layout_list
2664 struct dos_keyboard_map
*keyboard_map
;
2665 } keyboard_layout_list
[] =
2674 static struct dos_keyboard_map
*keyboard
;
2675 static int keyboard_map_all
;
2676 static int international_keyboard
;
2679 dos_set_keyboard (code
, always
)
2684 _go32_dpmi_registers regs
;
2686 /* See if Keyb.Com is installed (for international keyboard support).
2687 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2688 of Windows 9X! So don't do that! */
2690 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2691 _go32_dpmi_simulate_int (0x2f, ®s
);
2692 if (regs
.h
.al
== 0xff)
2693 international_keyboard
= 1;
2695 /* Initialize to US settings, for countries that don't have their own. */
2696 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2697 keyboard_map_all
= always
;
2698 dos_keyboard_layout
= 1;
2700 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2701 if (code
== keyboard_layout_list
[i
].country_code
)
2703 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2704 keyboard_map_all
= always
;
2705 dos_keyboard_layout
= code
;
2713 unsigned char char_code
; /* normal code */
2714 unsigned char meta_code
; /* M- code */
2715 unsigned char keypad_code
; /* keypad code */
2716 unsigned char editkey_code
; /* edit key */
2717 } keypad_translate_map
[] = {
2718 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2719 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2720 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2721 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2722 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2723 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2724 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2725 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2726 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2727 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2728 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2733 unsigned char char_code
; /* normal code */
2734 unsigned char keypad_code
; /* keypad code */
2735 } grey_key_translate_map
[] = {
2736 '/', 0xaf, /* kp-decimal */
2737 '*', 0xaa, /* kp-multiply */
2738 '-', 0xad, /* kp-subtract */
2739 '+', 0xab, /* kp-add */
2740 '\r', 0x8d /* kp-enter */
2743 static unsigned short
2744 ibmpc_translate_map
[] =
2746 /* --------------- 00 to 0f --------------- */
2747 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2748 Alt
| ModFct
| 0x1b, /* Escape */
2749 Normal
| 1, /* '1' */
2750 Normal
| 2, /* '2' */
2751 Normal
| 3, /* '3' */
2752 Normal
| 4, /* '4' */
2753 Normal
| 5, /* '5' */
2754 Normal
| 6, /* '6' */
2755 Normal
| 7, /* '7' */
2756 Normal
| 8, /* '8' */
2757 Normal
| 9, /* '9' */
2758 Normal
| 10, /* '0' */
2759 Normal
| 11, /* '-' */
2760 Normal
| 12, /* '=' */
2761 Special
| 0x08, /* Backspace */
2762 ModFct
| 0x74, /* Tab/Backtab */
2764 /* --------------- 10 to 1f --------------- */
2777 ModFct
| 0x0d, /* Return */
2782 /* --------------- 20 to 2f --------------- */
2791 Map
| 40, /* '\'' */
2793 Ignore
, /* Left shift */
2794 Map
| 41, /* '\\' */
2800 /* --------------- 30 to 3f --------------- */
2807 Ignore
, /* Right shift */
2808 Grey
| 1, /* Grey * */
2810 Normal
| 55, /* ' ' */
2811 Ignore
, /* Caps Lock */
2812 FctKey
| 0xbe, /* F1 */
2813 FctKey
| 0xbf, /* F2 */
2814 FctKey
| 0xc0, /* F3 */
2815 FctKey
| 0xc1, /* F4 */
2816 FctKey
| 0xc2, /* F5 */
2818 /* --------------- 40 to 4f --------------- */
2819 FctKey
| 0xc3, /* F6 */
2820 FctKey
| 0xc4, /* F7 */
2821 FctKey
| 0xc5, /* F8 */
2822 FctKey
| 0xc6, /* F9 */
2823 FctKey
| 0xc7, /* F10 */
2824 Ignore
, /* Num Lock */
2825 Ignore
, /* Scroll Lock */
2826 KeyPad
| 7, /* Home */
2827 KeyPad
| 8, /* Up */
2828 KeyPad
| 9, /* Page Up */
2829 Grey
| 2, /* Grey - */
2830 KeyPad
| 4, /* Left */
2831 KeyPad
| 5, /* Keypad 5 */
2832 KeyPad
| 6, /* Right */
2833 Grey
| 3, /* Grey + */
2834 KeyPad
| 1, /* End */
2836 /* --------------- 50 to 5f --------------- */
2837 KeyPad
| 2, /* Down */
2838 KeyPad
| 3, /* Page Down */
2839 KeyPad
| 0, /* Insert */
2840 KeyPad
| 10, /* Delete */
2841 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2842 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2843 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2844 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2845 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2846 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2847 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2848 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2849 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2850 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2851 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2852 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2854 /* --------------- 60 to 6f --------------- */
2855 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2856 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2857 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2858 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2859 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2860 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2861 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2862 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2863 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2864 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2865 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2866 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2867 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2868 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2869 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2870 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2872 /* --------------- 70 to 7f --------------- */
2873 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2874 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2875 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2876 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2877 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2878 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2879 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2880 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2881 Alt
| Map
| 1, /* '1' */
2882 Alt
| Map
| 2, /* '2' */
2883 Alt
| Map
| 3, /* '3' */
2884 Alt
| Map
| 4, /* '4' */
2885 Alt
| Map
| 5, /* '5' */
2886 Alt
| Map
| 6, /* '6' */
2887 Alt
| Map
| 7, /* '7' */
2888 Alt
| Map
| 8, /* '8' */
2890 /* --------------- 80 to 8f --------------- */
2891 Alt
| Map
| 9, /* '9' */
2892 Alt
| Map
| 10, /* '0' */
2893 Alt
| Map
| 11, /* '-' */
2894 Alt
| Map
| 12, /* '=' */
2895 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2896 FctKey
| 0xc8, /* F11 */
2897 FctKey
| 0xc9, /* F12 */
2898 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2899 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2900 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2901 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2902 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2903 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2904 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2905 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2906 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2908 /* --------------- 90 to 9f --------------- */
2909 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2910 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2911 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2912 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2913 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2914 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2915 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2916 Alt
| FctKey
| 0x50, /* (Alt) Home */
2917 Alt
| FctKey
| 0x52, /* (Alt) Up */
2918 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2919 Ignore
, /* NO KEY */
2920 Alt
| FctKey
| 0x51, /* (Alt) Left */
2921 Ignore
, /* NO KEY */
2922 Alt
| FctKey
| 0x53, /* (Alt) Right */
2923 Ignore
, /* NO KEY */
2924 Alt
| FctKey
| 0x57, /* (Alt) End */
2926 /* --------------- a0 to af --------------- */
2927 Alt
| KeyPad
| 2, /* (Alt) Down */
2928 Alt
| KeyPad
| 3, /* (Alt) Page Down */
2929 Alt
| KeyPad
| 0, /* (Alt) Insert */
2930 Alt
| KeyPad
| 10, /* (Alt) Delete */
2931 Alt
| Grey
| 0, /* (Alt) Grey / */
2932 Alt
| FctKey
| 0x09, /* (Alt) Tab */
2933 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
2936 /* These bit-positions corresponds to values returned by BIOS */
2937 #define SHIFT_P 0x0003 /* two bits! */
2938 #define CTRL_P 0x0004
2939 #define ALT_P 0x0008
2940 #define SCRLOCK_P 0x0010
2941 #define NUMLOCK_P 0x0020
2942 #define CAPSLOCK_P 0x0040
2943 #define ALT_GR_P 0x0800
2944 #define SUPER_P 0x4000 /* pseudo */
2945 #define HYPER_P 0x8000 /* pseudo */
2948 dos_get_modifiers (keymask
)
2955 /* Calculate modifier bits */
2956 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
2957 int86 (0x16, ®s
, ®s
);
2961 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
2962 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2966 mask
= regs
.h
.al
& (SHIFT_P
|
2967 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2969 /* Do not break international keyboard support. */
2970 /* When Keyb.Com is loaded, the right Alt key is */
2971 /* used for accessing characters like { and } */
2972 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
2975 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
2978 if (dos_hyper_key
== 1)
2981 modifiers
|= hyper_modifier
;
2983 else if (dos_super_key
== 1)
2986 modifiers
|= super_modifier
;
2988 else if (!international_keyboard
)
2990 /* If Keyb.Com is NOT installed, let Right Alt behave
2991 like the Left Alt. */
2997 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3000 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3002 if (dos_hyper_key
== 2)
3005 modifiers
|= hyper_modifier
;
3007 else if (dos_super_key
== 2)
3010 modifiers
|= super_modifier
;
3018 modifiers
|= shift_modifier
;
3020 modifiers
|= ctrl_modifier
;
3022 modifiers
|= meta_modifier
;
3029 #define NUM_RECENT_DOSKEYS (100)
3030 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3031 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3032 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3034 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3035 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3036 Each input key receives two values in this vector: first the ASCII code,\n\
3037 and then the scan code.")
3040 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3043 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3044 return Fvector (total_doskeys
, keys
);
3047 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3048 bcopy (keys
+ recent_doskeys_index
,
3049 XVECTOR (val
)->contents
,
3050 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3052 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3053 recent_doskeys_index
* sizeof (Lisp_Object
));
3058 /* Get a char from keyboard. Function keys are put into the event queue. */
3060 extern void kbd_buffer_store_event (struct input_event
*);
3065 struct input_event event
;
3068 #ifndef HAVE_X_WINDOWS
3069 /* Maybe put the cursor where it should be. */
3070 IT_cmgoto (SELECTED_FRAME());
3073 /* The following condition is equivalent to `kbhit ()', except that
3074 it uses the bios to do its job. This pleases DESQview/X. */
3075 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3076 int86 (0x16, ®s
, ®s
),
3077 (regs
.x
.flags
& 0x40) == 0)
3080 register unsigned char c
;
3081 int sc
, code
= -1, mask
, kp_mode
;
3084 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3085 int86 (0x16, ®s
, ®s
);
3090 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3092 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3093 recent_doskeys_index
= 0;
3094 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3096 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3097 recent_doskeys_index
= 0;
3099 modifiers
= dos_get_modifiers (&mask
);
3101 #ifndef HAVE_X_WINDOWS
3102 if (!NILP (Vdos_display_scancodes
))
3105 sprintf (buf
, "%02x:%02x*%04x",
3106 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3107 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3115 case 10: /* Ctrl Grey Enter */
3116 code
= Ctrl
| Grey
| 4;
3118 case 13: /* Grey Enter */
3121 case '/': /* Grey / */
3131 /* Try the keyboard-private translation table first. */
3132 if (keyboard
->translate_table
)
3134 struct kbd_translate
*p
= keyboard
->translate_table
;
3138 if (p
->sc
== sc
&& p
->ch
== c
)
3146 /* If the private table didn't translate it, use the general
3150 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3152 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3159 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3160 Emacs is ready to read a key. Therefore, if they press
3161 `Alt-x' when Emacs is busy, by the time we get to
3162 `dos_get_modifiers', they might have already released the
3163 Alt key, and Emacs gets just `x', which is BAD.
3164 However, for keys with the `Map' property set, the ASCII
3165 code returns zero iff Alt is pressed. So, when we DON'T
3166 have to support international_keyboard, we don't have to
3167 distinguish between the left and right Alt keys, and we
3168 can set the META modifier for any keys with the `Map'
3169 property if they return zero ASCII code (c = 0). */
3171 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3172 modifiers
|= meta_modifier
;
3174 modifiers
|= ctrl_modifier
;
3176 modifiers
|= shift_modifier
;
3179 switch (code
& 0xf000)
3182 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3184 c
= 0; /* Special */
3197 if (c
== 0) /* ctrl-break */
3199 return c
; /* ALT-nnn */
3201 if (!keyboard_map_all
)
3210 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3211 if (!keyboard_map_all
)
3215 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3216 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3220 code
= keyboard
->shifted
[code
];
3222 modifiers
&= ~shift_modifier
;
3225 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3226 code
= keyboard
->alt_gr
[code
];
3228 code
= keyboard
->unshifted
[code
];
3233 if (c
== 0xe0) /* edit key */
3236 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3237 kp_mode
= dos_keypad_mode
& 0x03;
3239 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3244 if (code
== 10 && dos_decimal_point
)
3245 return dos_decimal_point
;
3246 return keypad_translate_map
[code
].char_code
;
3249 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3253 code
= keypad_translate_map
[code
].meta_code
;
3254 modifiers
= meta_modifier
;
3258 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3265 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3266 if (dos_keypad_mode
& kp_mode
)
3267 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3269 code
= grey_key_translate_map
[code
].char_code
;
3278 event
.kind
= non_ascii_keystroke
;
3280 event
.kind
= ascii_keystroke
;
3282 event
.modifiers
= modifiers
;
3283 event
.frame_or_window
= selected_frame
;
3285 event
.timestamp
= event_timestamp ();
3286 kbd_buffer_store_event (&event
);
3289 if (have_mouse
> 0 && !mouse_preempted
)
3291 int but
, press
, x
, y
, ok
;
3292 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3294 /* Check for mouse movement *before* buttons. */
3295 mouse_check_moved ();
3297 /* If the mouse moved from the spot of its last sighting, we
3298 might need to update mouse highlight. */
3299 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3301 previous_help_echo
= help_echo
;
3302 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3304 IT_note_mouse_highlight (SELECTED_FRAME(),
3305 mouse_last_x
, mouse_last_y
);
3306 /* If the contents of the global variable help_echo has
3307 changed, generate a HELP_EVENT. */
3308 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3310 /* HELP_EVENT takes 2 events in the event loop. */
3311 event
.kind
= HELP_EVENT
;
3312 event
.frame_or_window
= selected_frame
;
3313 event
.arg
= help_echo_object
;
3314 event
.x
= make_number (help_echo_pos
);
3315 event
.timestamp
= event_timestamp ();
3317 kbd_buffer_store_event (&event
);
3318 if (WINDOWP (help_echo_window
))
3319 event
.frame_or_window
= help_echo_window
;
3320 event
.arg
= help_echo
;
3322 kbd_buffer_store_event (&event
);
3326 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3327 for (press
= 0; press
< 2; press
++)
3329 int button_num
= but
;
3332 ok
= mouse_pressed (but
, &x
, &y
);
3334 ok
= mouse_released (but
, &x
, &y
);
3337 /* Allow a simultaneous press/release of Mouse-1 and
3338 Mouse-2 to simulate Mouse-3 on two-button mice. */
3339 if (mouse_button_count
== 2 && but
< 2)
3341 int x2
, y2
; /* don't clobber original coordinates */
3343 /* If only one button is pressed, wait 100 msec and
3344 check again. This way, Speedy Gonzales isn't
3345 punished, while the slow get their chance. */
3346 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3347 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3352 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3353 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3358 event
.kind
= mouse_click
;
3359 event
.code
= button_num
;
3360 event
.modifiers
= dos_get_modifiers (0)
3361 | (press
? down_modifier
: up_modifier
);
3364 event
.frame_or_window
= selected_frame
;
3366 event
.timestamp
= event_timestamp ();
3367 kbd_buffer_store_event (&event
);
3375 static int prev_get_char
= -1;
3377 /* Return 1 if a key is ready to be read without suspending execution. */
3381 if (prev_get_char
!= -1)
3384 return ((prev_get_char
= dos_rawgetc ()) != -1);
3387 /* Read a key. Return -1 if no key is ready. */
3391 if (prev_get_char
!= -1)
3393 int c
= prev_get_char
;
3398 return dos_rawgetc ();
3401 #ifndef HAVE_X_WINDOWS
3402 /* See xterm.c for more info. */
3404 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3406 register int pix_x
, pix_y
;
3407 register int *x
, *y
;
3411 if (bounds
) abort ();
3413 /* Ignore clipping. */
3420 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3423 register int *pix_x
, *pix_y
;
3429 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3432 Actually, I don't know the meaning of all the parameters of the functions
3433 here -- I only know how they are called by xmenu.c. I could of course
3434 grab the nearest Xlib manual (down the hall, second-to-last door on the
3435 left), but I don't think it's worth the effort. */
3437 /* These hold text of the current and the previous menu help messages. */
3438 static char *menu_help_message
, *prev_menu_help_message
;
3439 /* Pane number and item number of the menu item which generated the
3440 last menu help message. */
3441 static int menu_help_paneno
, menu_help_itemno
;
3448 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3449 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3453 /* Allocate some (more) memory for MENU ensuring that there is room for one
3457 IT_menu_make_room (XMenu
*menu
)
3459 if (menu
->allocated
== 0)
3461 int count
= menu
->allocated
= 10;
3462 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3463 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3464 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3465 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3467 else if (menu
->allocated
== menu
->count
)
3469 int count
= menu
->allocated
= menu
->allocated
+ 10;
3471 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3473 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3475 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3477 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3481 /* Search the given menu structure for a given pane number. */
3484 IT_menu_search_pane (XMenu
*menu
, int pane
)
3489 for (i
= 0; i
< menu
->count
; i
++)
3490 if (menu
->submenu
[i
])
3492 if (pane
== menu
->panenumber
[i
])
3493 return menu
->submenu
[i
];
3494 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3500 /* Determine how much screen space a given menu needs. */
3503 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3505 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3508 maxheight
= menu
->count
;
3509 for (i
= 0; i
< menu
->count
; i
++)
3511 if (menu
->submenu
[i
])
3513 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3514 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3515 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3518 *width
= menu
->width
+ maxsubwidth
;
3519 *height
= maxheight
;
3522 /* Display MENU at (X,Y) using FACES. */
3525 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3527 int i
, j
, face
, width
;
3528 struct glyph
*text
, *p
;
3531 int enabled
, mousehere
;
3533 struct frame
*sf
= SELECTED_FRAME();
3535 menu_help_message
= NULL
;
3537 width
= menu
->width
;
3538 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3539 ScreenGetCursor (&row
, &col
);
3540 mouse_get_xy (&mx
, &my
);
3541 IT_update_begin (sf
);
3542 for (i
= 0; i
< menu
->count
; i
++)
3544 int max_width
= width
+ 2;
3546 IT_cursor_to (y
+ i
, x
);
3548 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3549 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3550 face
= faces
[enabled
+ mousehere
* 2];
3551 /* The following if clause means that we display the menu help
3552 strings even if the menu item is currently disabled. */
3553 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3555 menu_help_message
= menu
->help_text
[i
];
3556 menu_help_paneno
= pn
- 1;
3557 menu_help_itemno
= i
;
3560 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3562 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3566 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3569 else /* make '^x' */
3571 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3574 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3578 /* Don't let the menu text overflow into the next screen row. */
3579 if (x
+ max_width
> screen_size_X
)
3581 max_width
= screen_size_X
- x
;
3582 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3584 for (; j
< max_width
- 2; j
++, p
++)
3585 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3587 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3589 IT_write_glyphs (text
, max_width
);
3592 IT_cursor_to (row
, col
);
3596 /* --------------------------- X Menu emulation ---------------------- */
3598 /* Report availability of menus. */
3606 /* Create a brand new menu structure. */
3609 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3611 return IT_menu_create ();
3614 /* Create a new pane and place it on the outer-most level. It is not
3615 clear that it should be placed out there, but I don't know what else
3619 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3627 IT_menu_make_room (menu
);
3628 menu
->submenu
[menu
->count
] = IT_menu_create ();
3629 menu
->text
[menu
->count
] = txt
;
3630 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3631 menu
->help_text
[menu
->count
] = NULL
;
3634 /* Adjust length for possible control characters (which will
3635 be written as ^x). */
3636 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3640 if (len
> menu
->width
)
3643 return menu
->panecount
;
3646 /* Create a new item in a menu pane. */
3649 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3650 int foo
, char *txt
, int enable
, char *help_text
)
3656 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3658 IT_menu_make_room (menu
);
3659 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3660 menu
->text
[menu
->count
] = txt
;
3661 menu
->panenumber
[menu
->count
] = enable
;
3662 menu
->help_text
[menu
->count
] = help_text
;
3665 /* Adjust length for possible control characters (which will
3666 be written as ^x). */
3667 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3671 if (len
> menu
->width
)
3677 /* Decide where the menu would be placed if requested at (X,Y). */
3680 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3681 int *ulx
, int *uly
, int *width
, int *height
)
3683 IT_menu_calc_size (menu
, width
, height
);
3689 struct IT_menu_state
3691 void *screen_behind
;
3698 /* Display menu, wait for user's response, and return that response. */
3701 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3702 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3703 void (*help_callback
)(char *, int, int))
3705 struct IT_menu_state
*state
;
3710 Lisp_Object selectface
;
3711 int leave
, result
, onepane
;
3712 int title_faces
[4]; /* face to display the menu title */
3713 int buffers_num_deleted
= 0;
3714 struct frame
*sf
= SELECTED_FRAME();
3715 Lisp_Object saved_echo_area_message
;
3717 /* Just in case we got here without a mouse present... */
3718 if (have_mouse
<= 0)
3719 return XM_IA_SELECT
;
3720 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3721 around the display. */
3727 /* We will process all the mouse events directly, so we had
3728 better prevent dos_rawgetc from stealing them from us. */
3731 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3732 screensize
= screen_size
* 2;
3734 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3735 0, DEFAULT_FACE_ID
);
3737 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3738 0, DEFAULT_FACE_ID
);
3739 selectface
= intern ("msdos-menu-select-face");
3740 faces
[2] = lookup_derived_face (sf
, selectface
,
3742 faces
[3] = lookup_derived_face (sf
, selectface
,
3745 /* Make sure the menu title is always displayed with
3746 `msdos-menu-active-face', no matter where the mouse pointer is. */
3747 for (i
= 0; i
< 4; i
++)
3748 title_faces
[i
] = faces
[3];
3752 /* Don't let the title for the "Buffers" popup menu include a
3753 digit (which is ugly).
3755 This is a terrible kludge, but I think the "Buffers" case is
3756 the only one where the title includes a number, so it doesn't
3757 seem to be necessary to make this more general. */
3758 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3760 menu
->text
[0][7] = '\0';
3761 buffers_num_deleted
= 1;
3764 /* We need to save the current echo area message, so that we could
3765 restore it below, before we exit. See the commentary below,
3766 before the call to message_with_string. */
3767 saved_echo_area_message
= Fcurrent_message ();
3768 state
[0].menu
= menu
;
3770 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3772 /* Turn off the cursor. Otherwise it shows through the menu
3773 panes, which is ugly. */
3774 IT_display_cursor (0);
3776 /* Display the menu title. */
3777 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3778 if (buffers_num_deleted
)
3779 menu
->text
[0][7] = ' ';
3780 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3782 menu
->width
= menu
->submenu
[0]->width
;
3783 state
[0].menu
= menu
->submenu
[0];
3787 state
[0].menu
= menu
;
3789 state
[0].x
= x0
- 1;
3791 state
[0].pane
= onepane
;
3793 mouse_last_x
= -1; /* A hack that forces display. */
3797 if (!mouse_visible
) mouse_on ();
3798 mouse_check_moved ();
3799 if (sf
->mouse_moved
)
3801 sf
->mouse_moved
= 0;
3802 result
= XM_IA_SELECT
;
3803 mouse_get_xy (&x
, &y
);
3804 for (i
= 0; i
< statecount
; i
++)
3805 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3807 int dy
= y
- state
[i
].y
;
3808 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3810 if (!state
[i
].menu
->submenu
[dy
])
3811 if (state
[i
].menu
->panenumber
[dy
])
3812 result
= XM_SUCCESS
;
3814 result
= XM_IA_SELECT
;
3815 *pane
= state
[i
].pane
- 1;
3817 /* We hit some part of a menu, so drop extra menus that
3818 have been opened. That does not include an open and
3820 if (i
!= statecount
- 2
3821 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3822 while (i
!= statecount
- 1)
3826 ScreenUpdate (state
[statecount
].screen_behind
);
3827 if (screen_virtual_segment
)
3828 dosv_refresh_virtual_screen (0, screen_size
);
3829 xfree (state
[statecount
].screen_behind
);
3831 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3833 IT_menu_display (state
[i
].menu
,
3838 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3839 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3841 ScreenRetrieve (state
[statecount
].screen_behind
3842 = xmalloc (screensize
));
3844 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3845 state
[statecount
].y
= y
;
3850 IT_menu_display (state
[statecount
- 1].menu
,
3851 state
[statecount
- 1].y
,
3852 state
[statecount
- 1].x
,
3853 state
[statecount
- 1].pane
,
3858 if ((menu_help_message
|| prev_menu_help_message
)
3859 && menu_help_message
!= prev_menu_help_message
)
3861 help_callback (menu_help_message
,
3862 menu_help_paneno
, menu_help_itemno
);
3863 IT_display_cursor (0);
3864 prev_menu_help_message
= menu_help_message
;
3866 /* We are busy-waiting for the mouse to move, so let's be nice
3867 to other Windows applications by releasing our time slice. */
3870 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3872 /* Only leave if user both pressed and released the mouse, and in
3873 that order. This avoids popping down the menu pane unless
3874 the user is really done with it. */
3875 if (mouse_pressed (b
, &x
, &y
))
3877 while (mouse_button_depressed (b
, &x
, &y
))
3881 (void) mouse_released (b
, &x
, &y
);
3886 ScreenUpdate (state
[0].screen_behind
);
3887 if (screen_virtual_segment
)
3888 dosv_refresh_virtual_screen (0, screen_size
);
3890 /* We have a situation here. ScreenUpdate has just restored the
3891 screen contents as it was before we started drawing this menu.
3892 That includes any echo area message that could have been
3893 displayed back then. (In reality, that echo area message will
3894 almost always be the ``keystroke echo'' that echoes the sequence
3895 of menu items chosen by the user.) However, if the menu had some
3896 help messages, then displaying those messages caused Emacs to
3897 forget about the original echo area message. So when
3898 ScreenUpdate restored it, it created a discrepancy between the
3899 actual screen contents and what Emacs internal data structures
3902 To avoid this conflict, we force Emacs to restore the original
3903 echo area message as we found it when we entered this function.
3904 The irony of this is that we then erase the restored message
3905 right away, so the only purpose of restoring it is so that
3906 erasing it works correctly... */
3907 if (! NILP (saved_echo_area_message
))
3908 message_with_string ("%s", saved_echo_area_message
, 0);
3910 while (statecount
--)
3911 xfree (state
[statecount
].screen_behind
);
3912 IT_display_cursor (1); /* turn cursor back on */
3913 /* Clean up any mouse events that are waiting inside Emacs event queue.
3914 These events are likely to be generated before the menu was even
3915 displayed, probably because the user pressed and released the button
3916 (which invoked the menu) too quickly. If we don't remove these events,
3917 Emacs will process them after we return and surprise the user. */
3918 discard_mouse_events ();
3919 /* Allow mouse events generation by dos_rawgetc. */
3924 /* Dispose of a menu. */
3927 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3930 if (menu
->allocated
)
3932 for (i
= 0; i
< menu
->count
; i
++)
3933 if (menu
->submenu
[i
])
3934 XMenuDestroy (foo
, menu
->submenu
[i
]);
3936 xfree (menu
->submenu
);
3937 xfree (menu
->panenumber
);
3938 xfree (menu
->help_text
);
3941 menu_help_message
= prev_menu_help_message
= NULL
;
3945 x_pixel_width (struct frame
*f
)
3947 return FRAME_WIDTH (f
);
3951 x_pixel_height (struct frame
*f
)
3953 return FRAME_HEIGHT (f
);
3955 #endif /* !HAVE_X_WINDOWS */
3957 /* ----------------------- DOS / UNIX conversion --------------------- */
3959 void msdos_downcase_filename (unsigned char *);
3961 /* Destructively turn backslashes into slashes. */
3964 dostounix_filename (p
)
3967 msdos_downcase_filename (p
);
3977 /* Destructively turn slashes into backslashes. */
3980 unixtodos_filename (p
)
3983 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3997 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4000 getdefdir (drive
, dst
)
4004 char in_path
[4], *p
= in_path
;
4007 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4010 *p
++ = drive
+ 'A' - 1;
4017 _fixpath (in_path
, dst
);
4018 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4019 it queries the LFN support, so ignore that error. */
4020 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4023 msdos_downcase_filename (dst
);
4029 /* Remove all CR's that are followed by a LF. */
4034 register unsigned char *buf
;
4036 unsigned char *np
= buf
;
4037 unsigned char *startp
= buf
;
4038 unsigned char *endp
= buf
+ n
;
4042 while (buf
< endp
- 1)
4046 if (*(++buf
) != 0x0a)
4057 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4059 /* In DJGPP v2.0, library `write' can call `malloc', which might
4060 cause relocation of the buffer whose address we get in ADDR.
4061 Here is a version of `write' that avoids calling `malloc',
4062 to serve us until such time as the library is fixed.
4063 Actually, what we define here is called `__write', because
4064 `write' is a stub that just jmp's to `__write' (to be
4065 POSIXLY-correct with respect to the global name-space). */
4067 #include <io.h> /* for _write */
4068 #include <libc/dosio.h> /* for __file_handle_modes[] */
4070 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4072 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4075 __write (int handle
, const void *buffer
, size_t count
)
4080 if(__file_handle_modes
[handle
] & O_BINARY
)
4081 return _write (handle
, buffer
, count
);
4085 const char *bp
= buffer
;
4086 int total_written
= 0;
4087 int nmoved
= 0, ncr
= 0;
4091 /* The next test makes sure there's space for at least 2 more
4092 characters in xbuf[], so both CR and LF can be put there. */
4104 if (xbp
>= XBUF_END
|| !count
)
4106 size_t to_write
= nmoved
+ ncr
;
4107 int written
= _write (handle
, xbuf
, to_write
);
4112 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4114 /* If some, but not all were written (disk full?), return
4115 an estimate of the total written bytes not counting CRs. */
4116 if (written
< to_write
)
4117 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4124 return total_written
;
4128 /* A low-level file-renaming function which works around Windows 95 bug.
4129 This is pulled directly out of DJGPP v2.01 library sources, and only
4130 used when you compile with DJGPP v2.0. */
4134 int _rename(const char *old
, const char *new)
4137 int olen
= strlen(old
) + 1;
4139 int use_lfn
= _USE_LFN
;
4140 char tempfile
[FILENAME_MAX
];
4141 const char *orig
= old
;
4144 r
.x
.dx
= __tb_offset
;
4145 r
.x
.di
= __tb_offset
+ olen
;
4146 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4150 /* Windows 95 bug: for some filenames, when you rename
4151 file -> file~ (as in Emacs, to leave a backup), the
4152 short 8+3 alias doesn't change, which effectively
4153 makes OLD and NEW the same file. We must rename
4154 through a temporary file to work around this. */
4156 char *pbase
= 0, *p
;
4157 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4158 int idx
= sizeof(try_char
) - 1;
4160 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4161 might point to another drive, which will fail the DOS call. */
4162 strcpy(tempfile
, old
);
4163 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4164 if (*p
== '/' || *p
== '\\' || *p
== ':')
4170 strcpy(pbase
, "X$$djren$$.$$temp$$");
4176 *pbase
= try_char
[--idx
];
4177 } while (_chmod(tempfile
, 0) != -1);
4180 _put_path2(tempfile
, olen
);
4182 __dpmi_int(0x21, &r
);
4185 errno
= __doserr_to_errno(r
.x
.ax
);
4189 /* Now create a file with the original name. This will
4190 ensure that NEW will always have a 8+3 alias
4191 different from that of OLD. (Seems to be required
4192 when NameNumericTail in the Registry is set to 0.) */
4193 lfn_fd
= _creat(old
, 0);
4195 olen
= strlen(tempfile
) + 1;
4197 r
.x
.di
= __tb_offset
+ olen
;
4206 _put_path2(new, olen
);
4208 __dpmi_int(0x21, &r
);
4211 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4212 remove(new); /* and try again */
4215 errno
= __doserr_to_errno(r
.x
.ax
);
4217 /* Restore to original name if we renamed it to temporary. */
4225 _put_path2(orig
, olen
);
4226 _put_path(tempfile
);
4228 __dpmi_int(0x21, &r
);
4237 /* Success. Delete the file possibly created to work
4238 around the Windows 95 bug. */
4240 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4244 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4246 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4248 "Return non-nil if long file names are supported on MSDOS.")
4251 return (_USE_LFN
? Qt
: Qnil
);
4254 /* Convert alphabetic characters in a filename to lower-case. */
4257 msdos_downcase_filename (p
)
4258 register unsigned char *p
;
4260 /* Always lower-case drive letters a-z, even if the filesystem
4261 preserves case in filenames.
4262 This is so MSDOS filenames could be compared by string comparison
4263 functions that are case-sensitive. Even case-preserving filesystems
4264 do not distinguish case in drive letters. */
4265 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4271 /* Under LFN we expect to get pathnames in their true case. */
4272 if (NILP (Fmsdos_long_file_names ()))
4274 if (*p
>= 'A' && *p
<= 'Z')
4278 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4280 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4281 When long filenames are supported, doesn't change FILENAME.\n\
4282 If FILENAME is not a string, returns nil.\n\
4283 The argument object is never altered--the value is a copy.")
4285 Lisp_Object filename
;
4289 if (! STRINGP (filename
))
4292 tem
= Fcopy_sequence (filename
);
4293 msdos_downcase_filename (XSTRING (tem
)->data
);
4297 /* The Emacs root directory as determined by init_environment. */
4299 static char emacsroot
[MAXPATHLEN
];
4302 rootrelativepath (rel
)
4305 static char result
[MAXPATHLEN
+ 10];
4307 strcpy (result
, emacsroot
);
4308 strcat (result
, "/");
4309 strcat (result
, rel
);
4313 /* Define a lot of environment variables if not already defined. Don't
4314 remove anything unless you know what you're doing -- lots of code will
4315 break if one or more of these are missing. */
4318 init_environment (argc
, argv
, skip_args
)
4325 static const char * const tempdirs
[] = {
4326 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4329 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4331 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4332 temporary files and assume "/tmp" if $TMPDIR is unset, which
4333 will break on DOS/Windows. Refuse to work if we cannot find
4334 a directory, not even "c:/", usable for that purpose. */
4335 for (i
= 0; i
< imax
; i
++)
4337 const char *tmp
= tempdirs
[i
];
4340 tmp
= getenv (tmp
+ 1);
4341 /* Note that `access' can lie to us if the directory resides on a
4342 read-only filesystem, like CD-ROM or a write-protected floppy.
4343 The only way to be really sure is to actually create a file and
4344 see if it succeeds. But I think that's too much to ask. */
4345 if (tmp
&& access (tmp
, D_OK
) == 0)
4347 setenv ("TMPDIR", tmp
, 1);
4354 Fcons (build_string ("no usable temporary directories found!!"),
4356 "While setting TMPDIR: ");
4358 /* Note the startup time, so we know not to clear the screen if we
4359 exit immediately; see IT_reset_terminal_modes.
4360 (Yes, I know `clock' returns zero the first time it's called, but
4361 I do this anyway, in case some wiseguy changes that at some point.) */
4362 startup_time
= clock ();
4364 /* Find our root from argv[0]. Assuming argv[0] is, say,
4365 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4366 root
= alloca (MAXPATHLEN
+ 20);
4367 _fixpath (argv
[0], root
);
4368 msdos_downcase_filename (root
);
4369 len
= strlen (root
);
4370 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4374 && (strcmp (root
+ len
- 4, "/bin") == 0
4375 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4376 root
[len
- 4] = '\0';
4378 strcpy (root
, "c:/emacs"); /* let's be defensive */
4379 len
= strlen (root
);
4380 strcpy (emacsroot
, root
);
4382 /* We default HOME to our root. */
4383 setenv ("HOME", root
, 0);
4385 /* We default EMACSPATH to root + "/bin". */
4386 strcpy (root
+ len
, "/bin");
4387 setenv ("EMACSPATH", root
, 0);
4389 /* I don't expect anybody to ever use other terminals so the internal
4390 terminal is the default. */
4391 setenv ("TERM", "internal", 0);
4393 #ifdef HAVE_X_WINDOWS
4394 /* Emacs expects DISPLAY to be set. */
4395 setenv ("DISPLAY", "unix:0.0", 0);
4398 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4399 downcase it and mirror the backslashes. */
4400 s
= getenv ("COMSPEC");
4401 if (!s
) s
= "c:/command.com";
4402 t
= alloca (strlen (s
) + 1);
4404 dostounix_filename (t
);
4405 setenv ("SHELL", t
, 0);
4407 /* PATH is also downcased and backslashes mirrored. */
4408 s
= getenv ("PATH");
4410 t
= alloca (strlen (s
) + 3);
4411 /* Current directory is always considered part of MsDos's path but it is
4412 not normally mentioned. Now it is. */
4413 strcat (strcpy (t
, ".;"), s
);
4414 dostounix_filename (t
); /* Not a single file name, but this should work. */
4415 setenv ("PATH", t
, 1);
4417 /* In some sense all dos users have root privileges, so... */
4418 setenv ("USER", "root", 0);
4419 setenv ("NAME", getenv ("USER"), 0);
4421 /* Time zone determined from country code. To make this possible, the
4422 country code may not span more than one time zone. In other words,
4423 in the USA, you lose. */
4425 switch (dos_country_code
)
4427 case 31: /* Belgium */
4428 case 32: /* The Netherlands */
4429 case 33: /* France */
4430 case 34: /* Spain */
4431 case 36: /* Hungary */
4432 case 38: /* Yugoslavia (or what's left of it?) */
4433 case 39: /* Italy */
4434 case 41: /* Switzerland */
4435 case 42: /* Tjekia */
4436 case 45: /* Denmark */
4437 case 46: /* Sweden */
4438 case 47: /* Norway */
4439 case 48: /* Poland */
4440 case 49: /* Germany */
4441 /* Daylight saving from last Sunday in March to last Sunday in
4442 September, both at 2AM. */
4443 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4445 case 44: /* United Kingdom */
4446 case 351: /* Portugal */
4447 case 354: /* Iceland */
4448 setenv ("TZ", "GMT+00", 0);
4450 case 81: /* Japan */
4451 case 82: /* Korea */
4452 setenv ("TZ", "JST-09", 0);
4454 case 90: /* Turkey */
4455 case 358: /* Finland */
4456 setenv ("TZ", "EET-02", 0);
4458 case 972: /* Israel */
4459 /* This is an approximation. (For exact rules, use the
4460 `zoneinfo/israel' file which comes with DJGPP, but you need
4461 to install it in `/usr/share/zoneinfo/' directory first.) */
4462 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4470 static int break_stat
; /* BREAK check mode status. */
4471 static int stdin_stat
; /* stdin IOCTL status. */
4475 /* These must be global. */
4476 static _go32_dpmi_seginfo ctrl_break_vector
;
4477 static _go32_dpmi_registers ctrl_break_regs
;
4478 static int ctrlbreakinstalled
= 0;
4480 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4483 ctrl_break_func (regs
)
4484 _go32_dpmi_registers
*regs
;
4490 install_ctrl_break_check ()
4492 if (!ctrlbreakinstalled
)
4494 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4495 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4496 ctrlbreakinstalled
= 1;
4497 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4498 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4500 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4504 #endif /* __DJGPP__ < 2 */
4506 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4507 control chars by DOS. Determine the keyboard type. */
4512 union REGS inregs
, outregs
;
4513 static int first_time
= 1;
4515 break_stat
= getcbrk ();
4518 install_ctrl_break_check ();
4524 int86 (0x15, &inregs
, &outregs
);
4525 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4529 if (internal_terminal
4530 #ifdef HAVE_X_WINDOWS
4531 && inhibit_window_system
4535 inregs
.x
.ax
= 0x0021;
4536 int86 (0x33, &inregs
, &outregs
);
4537 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4540 /* Reportedly, the above doesn't work for some mouse drivers. There
4541 is an additional detection method that should work, but might be
4542 a little slower. Use that as an alternative. */
4543 inregs
.x
.ax
= 0x0000;
4544 int86 (0x33, &inregs
, &outregs
);
4545 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4550 have_mouse
= 1; /* enable mouse */
4552 mouse_setup_buttons (outregs
.x
.bx
);
4553 mouse_position_hook
= &mouse_get_pos
;
4557 #ifndef HAVE_X_WINDOWS
4559 /* Save the cursor shape used outside Emacs. */
4560 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4569 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4570 return (stdin_stat
!= -1);
4573 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4575 #else /* __DJGPP__ < 2 */
4579 /* I think it is wrong to overwrite `stdin_stat' every time
4580 but the first one this function is called, but I don't
4581 want to change the way it used to work in v1.x.--EZ */
4583 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4584 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4585 intdos (&inregs
, &outregs
);
4586 stdin_stat
= outregs
.h
.dl
;
4588 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4589 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4590 intdos (&inregs
, &outregs
);
4591 return !outregs
.x
.cflag
;
4593 #endif /* __DJGPP__ < 2 */
4596 /* Restore status of standard input and Ctrl-C checking. */
4601 union REGS inregs
, outregs
;
4603 setcbrk (break_stat
);
4608 #ifndef HAVE_X_WINDOWS
4609 /* Restore the cursor shape we found on startup. */
4613 inregs
.x
.cx
= outside_cursor
;
4614 int86 (0x10, &inregs
, &outregs
);
4618 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4620 #else /* not __DJGPP__ >= 2 */
4622 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4623 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4624 inregs
.x
.dx
= stdin_stat
;
4625 intdos (&inregs
, &outregs
);
4626 return !outregs
.x
.cflag
;
4628 #endif /* not __DJGPP__ >= 2 */
4632 /* Run command as specified by ARGV in directory DIR.
4633 The command is run with input from TEMPIN, output to
4634 file TEMPOUT and stderr to TEMPERR. */
4637 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4638 unsigned char **argv
;
4639 const char *working_dir
;
4640 int tempin
, tempout
, temperr
;
4643 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4644 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4645 int msshell
, result
= -1;
4646 int inbak
, outbak
, errbak
;
4650 /* Get current directory as MSDOS cwd is not per-process. */
4653 /* If argv[0] is the shell, it might come in any lettercase.
4654 Since `Fmember' is case-sensitive, we need to downcase
4655 argv[0], even if we are on case-preserving filesystems. */
4656 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4657 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4660 if (*pl
>= 'A' && *pl
<= 'Z')
4665 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4666 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4667 && !strcmp ("-c", argv
[1]);
4670 saveargv1
= argv
[1];
4671 saveargv2
= argv
[2];
4673 /* We only need to mirror slashes if a DOS shell will be invoked
4674 not via `system' (which does the mirroring itself). Yes, that
4675 means DJGPP v1.x will lose here. */
4676 if (argv
[2] && argv
[3])
4678 char *p
= alloca (strlen (argv
[2]) + 1);
4680 strcpy (argv
[2] = p
, saveargv2
);
4681 while (*p
&& isspace (*p
))
4693 chdir (working_dir
);
4697 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4698 goto done
; /* Allocation might fail due to lack of descriptors. */
4701 mouse_get_xy (&x
, &y
);
4703 dos_ttcooked (); /* do it here while 0 = stdin */
4711 if (msshell
&& !argv
[3])
4713 /* MS-DOS native shells are too restrictive. For starters, they
4714 cannot grok commands longer than 126 characters. In DJGPP v2
4715 and later, `system' is much smarter, so we'll call it instead. */
4719 /* A shell gets a single argument--its full command
4720 line--whose original was saved in `saveargv2'. */
4722 /* Don't let them pass empty command lines to `system', since
4723 with some shells it will try to invoke an interactive shell,
4724 which will hang Emacs. */
4725 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4729 extern char **environ
;
4730 char **save_env
= environ
;
4731 int save_system_flags
= __system_flags
;
4733 /* Request the most powerful version of `system'. We need
4734 all the help we can get to avoid calling stock DOS shells. */
4735 __system_flags
= (__system_redirect
4736 | __system_use_shell
4737 | __system_allow_multiple_cmds
4738 | __system_allow_long_cmds
4739 | __system_handle_null_commands
4740 | __system_emulate_chdir
);
4743 result
= system (cmnd
);
4744 __system_flags
= save_system_flags
;
4748 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4752 #endif /* __DJGPP__ > 1 */
4754 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4759 emacs_close (inbak
);
4760 emacs_close (outbak
);
4761 emacs_close (errbak
);
4767 mouse_moveto (x
, y
);
4770 /* Some programs might change the meaning of the highest bit of the
4771 text attribute byte, so we get blinking characters instead of the
4772 bright background colors. Restore that. */
4779 argv
[1] = saveargv1
;
4780 argv
[2] = saveargv2
;
4788 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4795 /* ------------------------- Compatibility functions -------------------
4800 /* Hostnames for a pc are not really funny,
4801 but they are used in change log so we emulate the best we can. */
4803 gethostname (p
, size
)
4807 char *q
= egetenv ("HOSTNAME");
4814 /* When time zones are set from Ms-Dos too many C-libraries are playing
4815 tricks with time values. We solve this by defining our own version
4816 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4817 once and after each call to `tzset' with TZ changed. That is
4818 accomplished by aliasing tzset to init_gettimeofday. */
4820 static struct tm time_rec
;
4823 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4831 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4835 time_rec
.tm_year
= d
.da_year
- 1900;
4836 time_rec
.tm_mon
= d
.da_mon
- 1;
4837 time_rec
.tm_mday
= d
.da_day
;
4840 time_rec
.tm_hour
= t
.ti_hour
;
4841 time_rec
.tm_min
= t
.ti_min
;
4842 time_rec
.tm_sec
= t
.ti_sec
;
4845 tm
.tm_gmtoff
= dos_timezone_offset
;
4847 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4848 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4850 /* Ignore tzp; it's obsolescent. */
4854 #endif /* __DJGPP__ < 2 */
4857 * A list of unimplemented functions that we silently ignore.
4861 unsigned alarm (s
) unsigned s
; {}
4862 fork () { return 0; }
4863 int kill (x
, y
) int x
, y
; { return -1; }
4865 void volatile pause () {}
4866 sigsetmask (x
) int x
; { return 0; }
4867 sigblock (mask
) int mask
; { return 0; }
4870 void request_sigio (void) {}
4871 setpgrp () {return 0; }
4872 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4873 void unrequest_sigio (void) {}
4877 #ifdef POSIX_SIGNALS
4879 /* Augment DJGPP library POSIX signal functions. This is needed
4880 as of DJGPP v2.01, but might be in the library in later releases. */
4882 #include <libc/bss.h>
4884 /* A counter to know when to re-initialize the static sets. */
4885 static int sigprocmask_count
= -1;
4887 /* Which signals are currently blocked (initially none). */
4888 static sigset_t current_mask
;
4890 /* Which signals are pending (initially none). */
4891 static sigset_t pending_signals
;
4893 /* Previous handlers to restore when the blocked signals are unblocked. */
4894 typedef void (*sighandler_t
)(int);
4895 static sighandler_t prev_handlers
[320];
4897 /* A signal handler which just records that a signal occured
4898 (it will be raised later, if and when the signal is unblocked). */
4900 sig_suspender (signo
)
4903 sigaddset (&pending_signals
, signo
);
4907 sigprocmask (how
, new_set
, old_set
)
4909 const sigset_t
*new_set
;
4915 /* If called for the first time, initialize. */
4916 if (sigprocmask_count
!= __bss_count
)
4918 sigprocmask_count
= __bss_count
;
4919 sigemptyset (&pending_signals
);
4920 sigemptyset (¤t_mask
);
4921 for (signo
= 0; signo
< 320; signo
++)
4922 prev_handlers
[signo
] = SIG_ERR
;
4926 *old_set
= current_mask
;
4931 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4937 sigemptyset (&new_mask
);
4939 /* DJGPP supports upto 320 signals. */
4940 for (signo
= 0; signo
< 320; signo
++)
4942 if (sigismember (¤t_mask
, signo
))
4943 sigaddset (&new_mask
, signo
);
4944 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4946 sigaddset (&new_mask
, signo
);
4948 /* SIGKILL is silently ignored, as on other platforms. */
4949 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4950 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
4952 if (( how
== SIG_UNBLOCK
4953 && sigismember (&new_mask
, signo
)
4954 && sigismember (new_set
, signo
))
4955 || (how
== SIG_SETMASK
4956 && sigismember (&new_mask
, signo
)
4957 && !sigismember (new_set
, signo
)))
4959 sigdelset (&new_mask
, signo
);
4960 if (prev_handlers
[signo
] != SIG_ERR
)
4962 signal (signo
, prev_handlers
[signo
]);
4963 prev_handlers
[signo
] = SIG_ERR
;
4965 if (sigismember (&pending_signals
, signo
))
4967 sigdelset (&pending_signals
, signo
);
4972 current_mask
= new_mask
;
4976 #else /* not POSIX_SIGNALS */
4978 sigsetmask (x
) int x
; { return 0; }
4979 sigblock (mask
) int mask
; { return 0; }
4981 #endif /* not POSIX_SIGNALS */
4982 #endif /* __DJGPP__ > 1 */
4985 #include "sysselect.h"
4987 #ifndef EMACS_TIME_ZERO_OR_NEG_P
4988 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
4989 ((long)(time).tv_sec < 0 \
4990 || ((time).tv_sec == 0 \
4991 && (long)(time).tv_usec <= 0))
4994 /* This yields the rest of the current time slice to the task manager.
4995 It should be called by any code which knows that it has nothing
4996 useful to do except idle.
4998 I don't use __dpmi_yield here, since versions of library before 2.02
4999 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5000 on some versions of Windows 9X. */
5003 dos_yield_time_slice (void)
5005 _go32_dpmi_registers r
;
5008 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5009 _go32_dpmi_simulate_int (0x2f, &r
);
5014 /* Only event queue is checked. */
5015 /* We don't have to call timer_check here
5016 because wait_reading_process_input takes care of that. */
5018 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5020 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5021 EMACS_TIME
*timeout
;
5029 check_input
= FD_ISSET (0, rfds
);
5040 /* If we are looking only for the terminal, with no timeout,
5041 just read it and wait -- that's more efficient. */
5044 while (!detect_input_pending ())
5046 dos_yield_time_slice ();
5051 EMACS_TIME clnow
, cllast
, cldiff
;
5054 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5056 while (!check_input
|| !detect_input_pending ())
5059 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5060 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5062 /* When seconds wrap around, we assume that no more than
5063 1 minute passed since last `gettime'. */
5064 if (EMACS_TIME_NEG_P (cldiff
))
5065 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5066 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5068 /* Stop when timeout value crosses zero. */
5069 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5072 dos_yield_time_slice ();
5082 * Define overlaid functions:
5084 * chdir -> sys_chdir
5085 * tzset -> init_gettimeofday
5086 * abort -> dos_abort
5091 extern int chdir ();
5097 int len
= strlen (path
);
5098 char *tmp
= (char *)path
;
5100 if (*tmp
&& tmp
[1] == ':')
5102 if (getdisk () != tolower (tmp
[0]) - 'a')
5103 setdisk (tolower (tmp
[0]) - 'a');
5104 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5108 if (len
> 1 && (tmp
[len
- 1] == '/'))
5110 char *tmp1
= (char *) alloca (len
+ 1);
5121 extern void tzset (void);
5124 init_gettimeofday ()
5130 ltm
= gtm
= time (NULL
);
5131 ltm
= mktime (lstm
= localtime (<m
));
5132 gtm
= mktime (gmtime (>m
));
5133 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5134 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5135 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5142 dos_abort (file
, line
)
5146 char buffer1
[200], buffer2
[400];
5149 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5150 for (i
= j
= 0; buffer1
[i
]; i
++) {
5151 buffer2
[j
++] = buffer1
[i
];
5152 buffer2
[j
++] = 0x70;
5154 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5155 ScreenSetCursor (2, 0);
5163 ScreenSetCursor (10, 0);
5164 cputs ("\r\n\nEmacs aborted!\r\n");
5166 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5167 if (screen_virtual_segment
)
5168 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5169 /* Generate traceback, so we could tell whodunit. */
5170 signal (SIGINT
, SIG_DFL
);
5171 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5172 #else /* __DJGPP_MINOR__ >= 2 */
5174 #endif /* __DJGPP_MINOR__ >= 2 */
5180 /* The following variables are required so that cus-start.el won't
5181 complain about unbound variables. */
5182 #ifndef HAVE_X_WINDOWS
5183 /* Search path for bitmap files (xfns.c). */
5184 Lisp_Object Vx_bitmap_file_path
;
5185 int x_stretch_cursor_p
;
5187 #ifndef subprocesses
5188 /* Nonzero means delete a process right away if it exits (process.c). */
5189 static int delete_exited_processes
;
5194 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5195 staticpro (&recent_doskeys
);
5196 #ifndef HAVE_X_WINDOWS
5198 staticpro (&help_echo
);
5199 help_echo_object
= Qnil
;
5200 staticpro (&help_echo_object
);
5201 help_echo_window
= Qnil
;
5202 staticpro (&help_echo_window
);
5203 previous_help_echo
= Qnil
;
5204 staticpro (&previous_help_echo
);
5207 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5208 "List of directories to search for bitmap files for X.");
5209 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5211 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5212 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5213 For example, if a block cursor is over a tab, it will be drawn as\n\
5214 wide as that tab on the display. (No effect on MS-DOS.)");
5215 x_stretch_cursor_p
= 0;
5217 /* The following three are from xfns.c: */
5218 Qbackground_color
= intern ("background-color");
5219 staticpro (&Qbackground_color
);
5220 Qforeground_color
= intern ("foreground-color");
5221 staticpro (&Qforeground_color
);
5222 Qbar
= intern ("bar");
5224 Qcursor_type
= intern ("cursor-type");
5225 staticpro (&Qcursor_type
);
5226 Qreverse
= intern ("reverse");
5227 staticpro (&Qreverse
);
5229 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5230 "*Glyph to display instead of chars not supported by current codepage.\n\
5232 This variable is used only by MSDOS terminals.");
5233 Vdos_unsupported_char_glyph
= '\177';
5235 #ifndef subprocesses
5236 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5237 "*Non-nil means delete processes immediately when they exit.\n\
5238 nil means don't delete them until `list-processes' is run.");
5239 delete_exited_processes
= 0;
5242 defsubr (&Srecent_doskeys
);
5243 defsubr (&Smsdos_long_file_names
);
5244 defsubr (&Smsdos_downcase_filename
);
5245 defsubr (&Smsdos_remember_default_colors
);
5246 defsubr (&Smsdos_set_mouse_buttons
);