1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Morten Welinder */
22 /* New display, keyboard, and mouse control by Kim F. Storm */
24 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
33 #include <sys/param.h>
37 #include <string.h> /* for bzero and string functions */
38 #include <sys/stat.h> /* for _fixpath */
39 #include <unistd.h> /* for chdir, dup, dup2, etc. */
42 #include <io.h> /* for setmode */
43 #include <dpmi.h> /* for __dpmi_xxx stuff */
44 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
45 #include <libc/dosio.h> /* for _USE_LFN */
46 #include <conio.h> /* for cputs */
51 #include "termhooks.h"
53 #include "dispextern.h"
63 #include "blockinput.h"
68 /* #include <process.h> */
69 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
77 #define _dos_ds _go32_info_block.selector_for_linear_memory
83 #include "syssignal.h"
89 /* If other `malloc' than ours is used, force our `sbrk' behave like
90 Unix programs expect (resize memory blocks to keep them contiguous).
91 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
92 because that's what `gmalloc' expects to get. */
96 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
97 #else /* not REL_ALLOC */
98 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
99 #endif /* not REL_ALLOC */
100 #endif /* GNU_MALLOC */
102 #endif /* not SYSTEM_MALLOC */
103 #endif /* __DJGPP__ > 1 */
122 /* ------------------------ Mouse control ---------------------------
124 * Coordinates are in screen positions and zero based.
125 * Mouse buttons are numbered from left to right and also zero based.
128 /* This used to be in termhooks.h, but mainstream Emacs code no longer
129 uses it, and it was removed... */
130 #define NUM_MOUSE_BUTTONS (5)
132 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
133 static int mouse_visible
;
135 static int mouse_last_x
;
136 static int mouse_last_y
;
138 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
139 static int mouse_button_count
;
146 if (have_mouse
> 0 && !mouse_visible
)
149 fprintf (termscript
, "<M_ON>");
151 int86 (0x33, ®s
, ®s
);
161 if (have_mouse
> 0 && mouse_visible
)
164 fprintf (termscript
, "<M_OFF>");
166 int86 (0x33, ®s
, ®s
);
172 mouse_setup_buttons (int n_buttons
)
176 mouse_button_count
= 3;
177 mouse_button_translate
[0] = 0; /* Left */
178 mouse_button_translate
[1] = 2; /* Middle */
179 mouse_button_translate
[2] = 1; /* Right */
181 else /* two, what else? */
183 mouse_button_count
= 2;
184 mouse_button_translate
[0] = 0;
185 mouse_button_translate
[1] = 1;
189 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
190 1, 1, "NSet number of mouse buttons to: ",
191 "Set the number of mouse buttons to use by Emacs.\n\
192 This is useful with mice that report the number of buttons inconsistently,\n\
193 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of\n\
194 them. This happens with wheeled mice on Windows 9X, for example.")
196 Lisp_Object nbuttons
;
198 CHECK_NUMBER (nbuttons
, 0);
199 mouse_setup_buttons (XINT (nbuttons
));
204 mouse_get_xy (int *x
, int *y
)
209 int86 (0x33, ®s
, ®s
);
221 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
223 mouse_last_x
= regs
.x
.cx
= x
* 8;
224 mouse_last_y
= regs
.x
.dx
= y
* 8;
225 int86 (0x33, ®s
, ®s
);
229 mouse_pressed (b
, xp
, yp
)
234 if (b
>= mouse_button_count
)
237 regs
.x
.bx
= mouse_button_translate
[b
];
238 int86 (0x33, ®s
, ®s
);
240 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
241 return (regs
.x
.bx
!= 0);
245 mouse_released (b
, xp
, yp
)
250 if (b
>= mouse_button_count
)
253 regs
.x
.bx
= mouse_button_translate
[b
];
254 int86 (0x33, ®s
, ®s
);
256 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
257 return (regs
.x
.bx
!= 0);
261 mouse_button_depressed (b
, xp
, yp
)
266 if (b
>= mouse_button_count
)
269 int86 (0x33, ®s
, ®s
);
270 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
280 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
283 Lisp_Object
*bar_window
, *x
, *y
;
284 enum scroll_bar_part
*part
;
288 Lisp_Object frame
, tail
;
290 /* Clear the mouse-moved flag for every frame on this display. */
291 FOR_EACH_FRAME (tail
, frame
)
292 XFRAME (frame
)->mouse_moved
= 0;
294 *f
= SELECTED_FRAME();
296 mouse_get_xy (&ix
, &iy
);
297 *time
= event_timestamp ();
298 *x
= make_number (mouse_last_x
= ix
);
299 *y
= make_number (mouse_last_y
= iy
);
307 mouse_get_xy (&x
, &y
);
308 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
313 /* Force the mouse driver to ``forget'' about any button clicks until
316 mouse_clear_clicks (void)
320 for (b
= 0; b
< mouse_button_count
; b
++)
322 int dummy_x
, dummy_y
;
324 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
325 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
335 fprintf (termscript
, "<M_INIT>");
338 int86 (0x33, ®s
, ®s
);
340 /* Reset the mouse last press/release info. It seems that Windows
341 doesn't do that automatically when function 21h is called, which
342 causes Emacs to ``remember'' the click that switched focus to the
343 window just before Emacs was started from that window. */
344 mouse_clear_clicks ();
348 regs
.x
.dx
= 8 * (ScreenCols () - 1);
349 int86 (0x33, ®s
, ®s
);
353 regs
.x
.dx
= 8 * (ScreenRows () - 1);
354 int86 (0x33, ®s
, ®s
);
360 /* ------------------------- Screen control ----------------------
364 static int internal_terminal
= 0;
366 #ifndef HAVE_X_WINDOWS
367 extern unsigned char ScreenAttrib
;
368 static int screen_face
;
369 static int highlight
;
371 static int screen_size_X
;
372 static int screen_size_Y
;
373 static int screen_size
;
375 static int current_pos_X
;
376 static int current_pos_Y
;
377 static int new_pos_X
;
378 static int new_pos_Y
;
380 static void *startup_screen_buffer
;
381 static int startup_screen_size_X
;
382 static int startup_screen_size_Y
;
383 static int startup_pos_X
;
384 static int startup_pos_Y
;
385 static unsigned char startup_screen_attrib
;
387 static clock_t startup_time
;
389 static int term_setup_done
;
391 static unsigned short outside_cursor
;
393 /* Similar to the_only_frame. */
394 struct x_output the_only_x_display
;
396 /* Support for DOS/V (allows Japanese characters to be displayed on
397 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
399 /* Holds the address of the text-mode screen buffer. */
400 static unsigned long screen_old_address
= 0;
401 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
402 static unsigned short screen_virtual_segment
= 0;
403 static unsigned short screen_virtual_offset
= 0;
404 /* A flag to control how to display unibyte 8-bit characters. */
405 extern int unibyte_display_via_language_environment
;
410 /* Update the screen from a part of relocated DOS/V screen buffer which
411 begins at OFFSET and includes COUNT characters. */
413 dosv_refresh_virtual_screen (int offset
, int count
)
417 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
420 regs
.h
.ah
= 0xff; /* update relocated screen */
421 regs
.x
.es
= screen_virtual_segment
;
422 regs
.x
.di
= screen_virtual_offset
+ offset
;
424 __dpmi_int (0x10, ®s
);
429 dos_direct_output (y
, x
, buf
, len
)
435 int t0
= 2 * (x
+ y
* screen_size_X
);
436 int t
= t0
+ (int) ScreenPrimary
;
441 dosmemput (buf
++, 1, t
);
445 /* This is faster. */
446 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
447 _farnspokeb (t
, *buf
);
449 if (screen_virtual_segment
)
450 dosv_refresh_virtual_screen (t0
, l0
);
455 /* Flash the screen as a substitute for BEEPs. */
459 do_visible_bell (xorattr
)
460 unsigned char xorattr
;
465 movl _ScreenPrimary,%%eax
472 xorb %%al,%%gs:(%%ebx)
488 : "m" (xorattr
), "g" (screen_size
)
489 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
493 ScreenVisualBell (void)
495 /* This creates an xor-mask that will swap the default fore- and
496 background colors. */
497 do_visible_bell (((the_only_x_display
.foreground_pixel
498 ^ the_only_x_display
.background_pixel
)
503 #ifndef HAVE_X_WINDOWS
505 static int blink_bit
= -1; /* the state of the blink bit at startup */
507 /* Enable bright background colors. */
513 /* Remember the original state of the blink/bright-background bit.
514 It is stored at 0040:0065h in the BIOS data area. */
516 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
520 int86 (0x10, ®s
, ®s
);
523 /* Disable bright background colors (and enable blinking) if we found
524 the video system in that state at startup. */
526 maybe_enable_blinking (void)
534 int86 (0x10, ®s
, ®s
);
538 /* Return non-zero if the system has a VGA adapter. */
545 int86 (0x10, ®s
, ®s
);
546 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
551 /* Set the screen dimensions so that it can show no less than
552 ROWS x COLS frame. */
555 dos_set_window_size (rows
, cols
)
559 Lisp_Object video_mode
;
560 int video_mode_value
;
563 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
565 if (*rows
== current_rows
&& *cols
== current_cols
)
569 have_vga
= vga_installed ();
571 /* If the user specified a special video mode for these dimensions,
573 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
574 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
577 if (INTEGERP (video_mode
)
578 && (video_mode_value
= XINT (video_mode
)) > 0)
580 regs
.x
.ax
= video_mode_value
;
581 int86 (0x10, ®s
, ®s
);
585 /* Must hardware-reset the mouse, or else it won't update
586 its notion of screen dimensions for some non-standard
587 video modes. This is *painfully* slow... */
589 int86 (0x33, ®s
, ®s
);
593 /* Find one of the dimensions supported by standard EGA/VGA
594 which gives us at least the required dimensions. */
603 } std_dimension
[] = {
613 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
615 if (std_dimension
[i
].need_vga
<= have_vga
616 && std_dimension
[i
].rows
>= *rows
)
618 if (std_dimension
[i
].rows
!= current_rows
619 || *cols
!= current_cols
)
620 _set_screen_lines (std_dimension
[i
].rows
);
627 #else /* not __DJGPP__ > 1 */
629 else if (*rows
<= 25)
631 if (current_rows
!= 25 || current_cols
!= 80)
634 int86 (0x10, ®s
, ®s
);
637 int86 (0x10, ®s
, ®s
);
640 int86 (0x10, ®s
, ®s
);
642 int86 (0x10, ®s
, ®s
);
645 else if (*rows
<= 50)
646 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
647 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
650 int86 (0x10, ®s
, ®s
);
653 int86 (0x10, ®s
, ®s
);
656 int86 (0x10, ®s
, ®s
);
659 int86 (0x10, ®s
, ®s
);
661 #endif /* not __DJGPP__ > 1 */
669 /* Tell the caller what dimensions have been REALLY set. */
670 *rows
= ScreenRows ();
671 *cols
= ScreenCols ();
673 /* Update Emacs' notion of screen dimensions. */
674 screen_size_X
= *cols
;
675 screen_size_Y
= *rows
;
676 screen_size
= *cols
* *rows
;
679 /* If the dimensions changed, the mouse highlight info is invalid. */
680 if (current_rows
!= *rows
|| current_cols
!= *cols
)
682 struct frame
*f
= SELECTED_FRAME();
683 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
684 Lisp_Object window
= dpyinfo
->mouse_face_window
;
686 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
688 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
689 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
690 dpyinfo
->mouse_face_window
= Qnil
;
695 /* Enable bright background colors. */
698 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
699 be defensive anyway. */
700 if (screen_virtual_segment
)
701 dosv_refresh_virtual_screen (0, *cols
* *rows
);
704 /* If we write a character in the position where the mouse is,
705 the mouse cursor may need to be refreshed. */
715 mouse_get_xy (&x
, &y
);
716 if (y
!= new_pos_Y
|| x
< new_pos_X
)
722 #define DEFAULT_CURSOR_START (-1)
723 #define DEFAULT_CURSOR_WIDTH (-1)
724 #define BOX_CURSOR_WIDTH (-32)
726 /* Set cursor to begin at scan line START_LINE in the character cell
727 and extend for WIDTH scan lines. Scan lines are counted from top
728 of the character cell, starting from zero. */
730 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
733 unsigned desired_cursor
;
735 int max_line
, top_line
, bot_line
;
737 /* Avoid the costly BIOS call if F isn't the currently selected
738 frame. Allow for NULL as unconditionally meaning the selected
740 if (f
&& f
!= SELECTED_FRAME())
743 /* The character cell size in scan lines is stored at 40:85 in the
745 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
748 default: /* this relies on CGA cursor emulation being ON! */
765 if (width
== BOX_CURSOR_WIDTH
)
770 else if (start_line
!= DEFAULT_CURSOR_START
)
772 top_line
= start_line
;
773 bot_line
= top_line
- width
- 1;
775 else if (width
!= DEFAULT_CURSOR_WIDTH
)
778 bot_line
= -1 - width
;
781 top_line
= bot_line
+ 1;
785 /* [31, 0] seems to DTRT for all screen sizes. */
789 else /* WIDTH is positive */
791 if (start_line
!= DEFAULT_CURSOR_START
)
792 bot_line
= start_line
;
793 top_line
= bot_line
- (width
- 1);
796 /* If the current cursor shape is already what they want, we are
798 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
799 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
803 regs
.x
.cx
= desired_cursor
;
804 __dpmi_int (0x10, ®s
);
805 #endif /* __DJGPP__ > 1 */
809 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
811 if (EQ (cursor_type
, Qbar
))
813 /* Just BAR means the normal EGA/VGA cursor. */
814 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
816 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
818 Lisp_Object bar_parms
= XCDR (cursor_type
);
821 if (INTEGERP (bar_parms
))
823 /* Feature: negative WIDTH means cursor at the top
824 of the character cell, zero means invisible cursor. */
825 width
= XINT (bar_parms
);
826 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
829 else if (CONSP (bar_parms
)
830 && INTEGERP (XCAR (bar_parms
))
831 && INTEGERP (XCDR (bar_parms
)))
833 int start_line
= XINT (XCDR (bar_parms
));
835 width
= XINT (XCAR (bar_parms
));
836 msdos_set_cursor_shape (f
, start_line
, width
);
840 /* Treat anything unknown as "box cursor". This includes nil, so
841 that a frame which doesn't specify a cursor type gets a box,
842 which is the default in Emacs. */
843 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
856 union REGS inregs
, outregs
;
859 intdos (&inregs
, &outregs
);
863 /* Given a face id FACE, extract the face parameters to be used for
864 display until the face changes. The face parameters (actually, its
865 color) are used to construct the video attribute byte for each
866 glyph during the construction of the buffer that is then blitted to
869 IT_set_face (int face
)
871 struct frame
*sf
= SELECTED_FRAME();
872 struct face
*fp
= FACE_FROM_ID (sf
, face
);
873 struct face
*dfp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
874 unsigned long fg
, bg
, dflt_fg
, dflt_bg
;
879 /* The default face for the frame should always be realized and
887 dflt_fg
= dfp
->foreground
;
888 dflt_bg
= dfp
->background
;
890 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
891 colors mean use the colors of the default face, except that if
892 highlight is on, invert the foreground and the background. Note
893 that we assume all 16 colors to be available for the background,
894 since Emacs switches on this mode (and loses the blinking
895 attribute) at startup. */
896 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
897 fg
= FRAME_FOREGROUND_PIXEL (sf
);
898 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
899 fg
= FRAME_BACKGROUND_PIXEL (sf
);
900 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
901 bg
= FRAME_BACKGROUND_PIXEL (sf
);
902 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
903 bg
= FRAME_FOREGROUND_PIXEL (sf
);
905 /* Make sure highlighted lines really stand out, come what may. */
906 if ((highlight
|| fp
->tty_reverse_p
)
907 && (fg
== dflt_fg
&& bg
== dflt_bg
))
909 unsigned long tem
= fg
;
915 fprintf (termscript
, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face
,
916 highlight
? "H" : "", fp
->foreground
, fp
->background
, fg
, bg
);
917 if (fg
>= 0 && fg
< 16)
919 ScreenAttrib
&= 0xf0;
922 if (bg
>= 0 && bg
< 16)
924 ScreenAttrib
&= 0x0f;
925 ScreenAttrib
|= ((bg
& 0x0f) << 4);
929 Lisp_Object Vdos_unsupported_char_glyph
;
932 IT_write_glyphs (struct glyph
*str
, int str_len
)
934 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
935 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
936 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
937 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
938 register int sl
= str_len
;
939 register int tlen
= GLYPH_TABLE_LENGTH
;
940 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
942 /* If terminal_coding does any conversion, use it, otherwise use
943 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
944 because it always returns 1 if terminal_coding.src_multibyte is 1. */
945 struct coding_system
*coding
=
946 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
948 : &safe_terminal_coding
);
951 /* Do we need to consider conversion of unibyte characters to
953 int convert_unibyte_characters
954 = (NILP (current_buffer
->enable_multibyte_characters
)
955 && unibyte_display_via_language_environment
);
957 unsigned char conversion_buffer
[256];
958 int conversion_buffer_size
= sizeof conversion_buffer
;
960 if (str_len
<= 0) return;
962 screen_buf
= screen_bp
= alloca (str_len
* 2);
963 screen_buf_end
= screen_buf
+ str_len
* 2;
964 sf
= SELECTED_FRAME();
966 /* Since faces get cached and uncached behind our back, we can't
967 rely on their indices in the cache being consistent across
968 invocations. So always reset the screen face to the default
969 face of the frame, before writing glyphs, and let the glyphs
970 set the right face if it's different from the default. */
971 IT_set_face (DEFAULT_FACE_ID
);
973 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
975 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
978 int cf
, chlen
, enclen
;
979 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
982 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
983 only for the redisplay code to know how many columns does
984 this character occupy on the screen. Skip padding glyphs. */
985 if (CHAR_GLYPH_PADDING_P (*str
))
992 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
993 int glyph_not_in_table
= 0;
995 if (g
< 0 || g
>= tlen
)
997 /* This glyph doesn't have an entry in Vglyph_table. */
999 glyph_not_in_table
= 1;
1003 /* This glyph has an entry in Vglyph_table, so process
1004 any aliases before testing for simpleness. */
1005 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
1006 ch
= FAST_GLYPH_CHAR (g
);
1009 /* Convert the character code to multibyte, if they
1010 requested display via language environment. We only want
1011 to convert unibyte characters to multibyte in unibyte
1012 buffers! Otherwise, the 8-bit value in CH came from the
1013 display table set up to display foreign characters. */
1014 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1016 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1017 ch
= unibyte_char_to_multibyte (ch
);
1019 /* Invalid characters are displayed with a special glyph. */
1020 if (! CHAR_VALID_P (ch
, 0))
1022 g
= !NILP (Vdos_unsupported_char_glyph
)
1023 ? Vdos_unsupported_char_glyph
1024 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1025 ch
= FAST_GLYPH_CHAR (g
);
1028 /* If the face of this glyph is different from the current
1029 screen face, update the screen attribute byte. */
1030 cf
= FAST_GLYPH_FACE (g
);
1031 if (cf
!= screen_face
)
1032 IT_set_face (cf
); /* handles invalid faces gracefully */
1034 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1036 /* We generate the multi-byte form of CH in WORKBUF. */
1037 chlen
= CHAR_STRING (ch
, workbuf
);
1042 /* We have a string in Vglyph_table. */
1043 chlen
= GLYPH_LENGTH (tbase
, g
);
1044 buf
= GLYPH_STRING (tbase
, g
);
1047 /* If the character is not multibyte, don't bother converting it. */
1050 *conversion_buffer
= (unsigned char)ch
;
1056 coding
->src_multibyte
= 1;
1057 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1058 conversion_buffer_size
);
1059 chlen
-= coding
->consumed
;
1060 enclen
= coding
->produced
;
1062 /* Replace glyph codes that cannot be converted by
1063 terminal_coding with Vdos_unsupported_char_glyph. */
1064 if (*conversion_buffer
== '?')
1066 unsigned char *cbp
= conversion_buffer
;
1068 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1069 *cbp
++ = unsupported_char
;
1070 if (unsupported_face
!= screen_face
)
1071 IT_set_face (unsupported_face
);
1075 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1077 /* The allocated buffer for screen writes is too small.
1078 Flush it and loop again without incrementing STR, so
1079 that the next loop will begin with the same glyph. */
1080 int nbytes
= screen_bp
- screen_buf
;
1083 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1084 if (screen_virtual_segment
)
1085 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1086 new_pos_X
+= nbytes
/ 2;
1089 /* Prepare to reuse the same buffer again. */
1090 screen_bp
= screen_buf
;
1094 /* There's enough place in the allocated buffer to add
1095 the encoding of this glyph. */
1097 /* First, copy the encoded bytes. */
1098 for (bp
= conversion_buffer
; enclen
--; bp
++)
1100 *screen_bp
++ = (unsigned char)*bp
;
1101 *screen_bp
++ = ScreenAttrib
;
1103 fputc (*bp
, termscript
);
1106 /* Now copy the bytes not consumed by the encoding. */
1109 buf
+= coding
->consumed
;
1113 fputc (*buf
, termscript
);
1114 *screen_bp
++ = (unsigned char)*buf
++;
1115 *screen_bp
++ = ScreenAttrib
;
1119 /* Update STR and its remaining length. */
1126 /* Dump whatever is left in the screen buffer. */
1128 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1129 if (screen_virtual_segment
)
1130 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1131 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1133 /* We may have to output some codes to terminate the writing. */
1134 if (CODING_REQUIRE_FLUSHING (coding
))
1136 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1137 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1138 if (coding
->produced
> 0)
1140 screen_buf
= alloca (coding
->produced
* 2);
1141 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1142 coding
->produced
--; bp
++)
1144 *screen_bp
++ = (unsigned char)*bp
;
1145 *screen_bp
++ = ScreenAttrib
;
1147 fputc (*bp
, termscript
);
1149 offset
+= screen_bp
- screen_buf
;
1151 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1152 (int)ScreenPrimary
+ offset
);
1153 if (screen_virtual_segment
)
1154 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1155 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1160 /************************************************************************
1161 Mouse Highlight (and friends..)
1162 ************************************************************************/
1164 /* This is used for debugging, to turn off note_mouse_highlight. */
1165 int disable_mouse_highlight
;
1167 /* If non-nil, dos_rawgetc generates an event to display that string.
1168 (The display is done in keyboard.c:read_char, by calling
1170 static Lisp_Object help_echo
;
1171 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1173 /* These record the window, the object and the position where the help
1174 echo string was generated. */
1175 static Lisp_Object help_echo_window
;
1176 static Lisp_Object help_echo_object
;
1177 static int help_echo_pos
;
1179 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1181 /* Set the mouse pointer shape according to whether it is in the
1182 area where the mouse highlight is in effect. */
1184 IT_set_mouse_pointer (int mode
)
1186 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1187 many possibilities to change its shape, and the available
1188 functionality pretty much sucks (e.g., almost every reasonable
1189 shape will conceal the character it is on). Since the color of
1190 the pointer changes in the highlighted area, it is not clear to
1191 me whether anything else is required, anyway. */
1194 /* Display the active region described by mouse_face_*
1195 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1197 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1199 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1200 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1205 /* If window is in the process of being destroyed, don't bother
1207 if (w
->current_matrix
== NULL
)
1208 goto set_cursor_shape
;
1210 /* Recognize when we are called to operate on rows that don't exist
1211 anymore. This can happen when a window is split. */
1212 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1213 goto set_cursor_shape
;
1215 /* There's no sense to do anything if the mouse face isn't realized. */
1218 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1220 goto set_cursor_shape
;
1223 /* Note that mouse_face_beg_row etc. are window relative. */
1224 for (i
= dpyinfo
->mouse_face_beg_row
;
1225 i
<= dpyinfo
->mouse_face_end_row
;
1228 int start_hpos
, end_hpos
;
1229 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1231 /* Don't do anything if row doesn't have valid contents. */
1232 if (!row
->enabled_p
)
1235 /* For all but the first row, the highlight starts at column 0. */
1236 if (i
== dpyinfo
->mouse_face_beg_row
)
1237 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1241 if (i
== dpyinfo
->mouse_face_end_row
)
1242 end_hpos
= dpyinfo
->mouse_face_end_col
;
1244 end_hpos
= row
->used
[TEXT_AREA
];
1246 if (end_hpos
<= start_hpos
)
1248 /* Record that some glyphs of this row are displayed in
1250 row
->mouse_face_p
= hl
> 0;
1253 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1254 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1255 int nglyphs
= end_hpos
- start_hpos
;
1256 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1257 int start_offset
= offset
;
1260 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1261 kstart
, kstart
+ nglyphs
- 1, vpos
);
1264 IT_set_face (dpyinfo
->mouse_face_face_id
);
1265 /* Since we are going to change only the _colors_ of the
1266 displayed text, there's no need to go through all the
1267 pain of generating and encoding the text from the glyphs.
1268 Instead, we simply poke the attribute byte of each
1269 affected position in video memory with the colors
1270 computed by IT_set_face! */
1271 _farsetsel (_dos_ds
);
1274 _farnspokeb (offset
, ScreenAttrib
);
1277 if (screen_virtual_segment
)
1278 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1283 /* We are removing a previously-drawn mouse highlight. The
1284 safest way to do so is to redraw the glyphs anew, since
1285 all kinds of faces and display tables could have changed
1287 int nglyphs
= end_hpos
- start_hpos
;
1288 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1290 if (end_hpos
>= row
->used
[TEXT_AREA
])
1291 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1293 /* IT_write_glyphs writes at cursor position, so we need to
1294 temporarily move cursor coordinates to the beginning of
1295 the highlight region. */
1296 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1297 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1300 fprintf (termscript
, "<MH- %d-%d:%d>",
1301 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1302 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1304 fputs ("\n", termscript
);
1312 /* Change the mouse pointer shape. */
1313 IT_set_mouse_pointer (hl
);
1316 /* Clear out the mouse-highlighted active region.
1317 Redraw it un-highlighted first. */
1319 clear_mouse_face (struct display_info
*dpyinfo
)
1321 if (! NILP (dpyinfo
->mouse_face_window
))
1322 show_mouse_face (dpyinfo
, 0);
1324 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1325 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1326 dpyinfo
->mouse_face_window
= Qnil
;
1329 /* Find the glyph matrix position of buffer position POS in window W.
1330 *HPOS and *VPOS are set to the positions found. W's current glyphs
1331 must be up to date. If POS is above window start return (0, 0).
1332 If POS is after end of W, return end of last line in W. */
1334 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1338 int maybe_next_line_p
= 0;
1339 int line_start_position
;
1340 int yb
= window_text_bottom_y (w
);
1341 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1342 struct glyph_row
*best_row
= row
;
1346 if (row
->used
[TEXT_AREA
])
1347 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1349 line_start_position
= 0;
1351 if (line_start_position
> pos
)
1353 /* If the position sought is the end of the buffer,
1354 don't include the blank lines at the bottom of the window. */
1355 else if (line_start_position
== pos
1356 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1358 maybe_next_line_p
= 1;
1361 else if (line_start_position
> 0)
1364 /* Don't overstep the last matrix row, lest we get into the
1365 never-never land... */
1366 if (row
->y
+ 1 >= yb
)
1372 /* Find the right column within BEST_ROW. */
1375 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1377 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1380 charpos
= glyph
->charpos
;
1387 else if (charpos
> pos
)
1389 else if (charpos
> 0)
1393 /* If we're looking for the end of the buffer,
1394 and we didn't find it in the line we scanned,
1395 use the start of the following line. */
1396 if (maybe_next_line_p
)
1403 *hpos
= lastcol
+ 1;
1407 /* Take proper action when mouse has moved to the mode or top line of
1408 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1409 mode line. X is relative to the start of the text display area of
1410 W, so the width of bitmap areas and scroll bars must be subtracted
1411 to get a position relative to the start of the mode line. */
1413 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1415 struct frame
*f
= XFRAME (w
->frame
);
1416 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1417 struct glyph_row
*row
;
1420 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1422 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1426 extern Lisp_Object Qhelp_echo
;
1427 struct glyph
*glyph
, *end
;
1428 Lisp_Object help
, map
;
1430 /* Find the glyph under X. */
1431 glyph
= row
->glyphs
[TEXT_AREA
]
1432 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1433 end
= glyph
+ row
->used
[TEXT_AREA
];
1435 && STRINGP (glyph
->object
)
1436 && XSTRING (glyph
->object
)->intervals
1437 && glyph
->charpos
>= 0
1438 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1440 /* If we're on a string with `help-echo' text property,
1441 arrange for the help to be displayed. This is done by
1442 setting the global variable help_echo to the help string. */
1443 help
= Fget_text_property (make_number (glyph
->charpos
),
1444 Qhelp_echo
, glyph
->object
);
1448 XSETWINDOW (help_echo_window
, w
);
1449 help_echo_object
= glyph
->object
;
1450 help_echo_pos
= glyph
->charpos
;
1456 /* Take proper action when the mouse has moved to position X, Y on
1457 frame F as regards highlighting characters that have mouse-face
1458 properties. Also de-highlighting chars where the mouse was before.
1459 X and Y can be negative or out of range. */
1461 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1463 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1468 /* When a menu is active, don't highlight because this looks odd. */
1469 if (mouse_preempted
)
1472 if (disable_mouse_highlight
1473 || !f
->glyphs_initialized_p
)
1476 dpyinfo
->mouse_face_mouse_x
= x
;
1477 dpyinfo
->mouse_face_mouse_y
= y
;
1478 dpyinfo
->mouse_face_mouse_frame
= f
;
1480 if (dpyinfo
->mouse_face_defer
)
1485 dpyinfo
->mouse_face_deferred_gc
= 1;
1489 /* Which window is that in? */
1490 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1492 /* If we were displaying active text in another window, clear that. */
1493 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1494 clear_mouse_face (dpyinfo
);
1496 /* Not on a window -> return. */
1497 if (!WINDOWP (window
))
1500 /* Convert to window-relative coordinates. */
1501 w
= XWINDOW (window
);
1502 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1503 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1505 if (portion
== 1 || portion
== 3)
1507 /* Mouse is on the mode or top line. */
1508 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1512 IT_set_mouse_pointer (0);
1514 /* Are we in a window whose display is up to date?
1515 And verify the buffer's text has not changed. */
1516 if (/* Within text portion of the window. */
1518 && EQ (w
->window_end_valid
, w
->buffer
)
1519 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1520 && (XFASTINT (w
->last_overlay_modified
)
1521 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1524 struct glyph_row
*row
;
1525 struct glyph
*glyph
;
1526 int nrows
= w
->current_matrix
->nrows
;
1528 /* Find the glyph under X/Y. */
1530 if (y
>= 0 && y
< nrows
)
1532 row
= MATRIX_ROW (w
->current_matrix
, y
);
1533 /* Give up if some row before the one we are looking for is
1535 for (i
= 0; i
<= y
; i
++)
1536 if (!MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
)
1538 if (i
> y
/* all rows upto and including the one at Y are enabled */
1539 && row
->displays_text_p
1540 && x
< window_box_width (w
, TEXT_AREA
))
1542 glyph
= row
->glyphs
[TEXT_AREA
];
1543 if (x
>= row
->used
[TEXT_AREA
])
1548 if (!BUFFERP (glyph
->object
))
1554 /* Clear mouse face if X/Y not over text. */
1557 clear_mouse_face (dpyinfo
);
1561 if (!BUFFERP (glyph
->object
))
1563 pos
= glyph
->charpos
;
1565 /* Check for mouse-face and help-echo. */
1567 extern Lisp_Object Qmouse_face
;
1568 Lisp_Object mouse_face
, overlay
, position
;
1569 Lisp_Object
*overlay_vec
;
1571 struct buffer
*obuf
;
1574 /* If we get an out-of-range value, return now; avoid an error. */
1575 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1578 /* Make the window's buffer temporarily current for
1579 overlays_at and compute_char_face. */
1580 obuf
= current_buffer
;
1581 current_buffer
= XBUFFER (w
->buffer
);
1587 /* Is this char mouse-active or does it have help-echo? */
1588 XSETINT (position
, pos
);
1590 /* Put all the overlays we want in a vector in overlay_vec.
1591 Store the length in len. If there are more than 10, make
1592 enough space for all, and try again. */
1594 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1595 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1596 if (noverlays
> len
)
1599 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1600 noverlays
= overlays_at (pos
,
1601 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1604 /* Sort overlays into increasing priority order. */
1605 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1607 /* Check mouse-face highlighting. */
1608 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1609 && y
>= dpyinfo
->mouse_face_beg_row
1610 && y
<= dpyinfo
->mouse_face_end_row
1611 && (y
> dpyinfo
->mouse_face_beg_row
1612 || x
>= dpyinfo
->mouse_face_beg_col
)
1613 && (y
< dpyinfo
->mouse_face_end_row
1614 || x
< dpyinfo
->mouse_face_end_col
1615 || dpyinfo
->mouse_face_past_end
)))
1617 /* Clear the display of the old active region, if any. */
1618 clear_mouse_face (dpyinfo
);
1620 /* Find highest priority overlay that has a mouse-face prop. */
1622 for (i
= noverlays
- 1; i
>= 0; --i
)
1624 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1625 if (!NILP (mouse_face
))
1627 overlay
= overlay_vec
[i
];
1632 /* If no overlay applies, get a text property. */
1634 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1637 /* Handle the overlay case. */
1638 if (! NILP (overlay
))
1640 /* Find the range of text around this char that
1641 should be active. */
1642 Lisp_Object before
, after
;
1645 before
= Foverlay_start (overlay
);
1646 after
= Foverlay_end (overlay
);
1647 /* Record this as the current active region. */
1648 fast_find_position (w
, XFASTINT (before
),
1649 &dpyinfo
->mouse_face_beg_col
,
1650 &dpyinfo
->mouse_face_beg_row
);
1651 dpyinfo
->mouse_face_past_end
1652 = !fast_find_position (w
, XFASTINT (after
),
1653 &dpyinfo
->mouse_face_end_col
,
1654 &dpyinfo
->mouse_face_end_row
);
1655 dpyinfo
->mouse_face_window
= window
;
1656 dpyinfo
->mouse_face_face_id
1657 = face_at_buffer_position (w
, pos
, 0, 0,
1658 &ignore
, pos
+ 1, 1);
1660 /* Display it as active. */
1661 show_mouse_face (dpyinfo
, 1);
1663 /* Handle the text property case. */
1664 else if (! NILP (mouse_face
))
1666 /* Find the range of text around this char that
1667 should be active. */
1668 Lisp_Object before
, after
, beginning
, end
;
1671 beginning
= Fmarker_position (w
->start
);
1672 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1673 - XFASTINT (w
->window_end_pos
)));
1675 = Fprevious_single_property_change (make_number (pos
+ 1),
1677 w
->buffer
, beginning
);
1679 = Fnext_single_property_change (position
, Qmouse_face
,
1681 /* Record this as the current active region. */
1682 fast_find_position (w
, XFASTINT (before
),
1683 &dpyinfo
->mouse_face_beg_col
,
1684 &dpyinfo
->mouse_face_beg_row
);
1685 dpyinfo
->mouse_face_past_end
1686 = !fast_find_position (w
, XFASTINT (after
),
1687 &dpyinfo
->mouse_face_end_col
,
1688 &dpyinfo
->mouse_face_end_row
);
1689 dpyinfo
->mouse_face_window
= window
;
1690 dpyinfo
->mouse_face_face_id
1691 = face_at_buffer_position (w
, pos
, 0, 0,
1692 &ignore
, pos
+ 1, 1);
1694 /* Display it as active. */
1695 show_mouse_face (dpyinfo
, 1);
1699 /* Look for a `help-echo' property. */
1702 extern Lisp_Object Qhelp_echo
;
1704 /* Check overlays first. */
1706 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1708 overlay
= overlay_vec
[i
];
1709 help
= Foverlay_get (overlay
, Qhelp_echo
);
1715 help_echo_window
= window
;
1716 help_echo_object
= overlay
;
1717 help_echo_pos
= pos
;
1719 /* Try text properties. */
1720 else if (NILP (help
)
1721 && ((STRINGP (glyph
->object
)
1722 && glyph
->charpos
>= 0
1723 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1724 || (BUFFERP (glyph
->object
)
1725 && glyph
->charpos
>= BEGV
1726 && glyph
->charpos
< ZV
)))
1728 help
= Fget_text_property (make_number (glyph
->charpos
),
1729 Qhelp_echo
, glyph
->object
);
1733 help_echo_window
= window
;
1734 help_echo_object
= glyph
->object
;
1735 help_echo_pos
= glyph
->charpos
;
1742 current_buffer
= obuf
;
1748 IT_clear_end_of_line (int first_unused
)
1752 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1753 extern int fatal_error_in_progress
;
1755 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1759 i
= (j
= first_unused
- new_pos_X
) * 2;
1761 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1762 spaces
= sp
= alloca (i
);
1767 *sp
++ = ScreenAttrib
;
1771 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1772 if (screen_virtual_segment
)
1773 dosv_refresh_virtual_screen (offset
, i
/ 2);
1775 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1776 Let's follow their lead, in case someone relies on this. */
1777 new_pos_X
= first_unused
;
1781 IT_clear_screen (void)
1784 fprintf (termscript
, "<CLR:SCR>");
1788 if (screen_virtual_segment
)
1789 dosv_refresh_virtual_screen (0, screen_size
);
1790 new_pos_X
= new_pos_Y
= 0;
1794 IT_clear_to_end (void)
1797 fprintf (termscript
, "<CLR:EOS>");
1799 while (new_pos_Y
< screen_size_Y
) {
1801 IT_clear_end_of_line (screen_size_X
);
1807 IT_cursor_to (int y
, int x
)
1810 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1815 static int cursor_cleared
;
1818 IT_display_cursor (int on
)
1820 if (on
&& cursor_cleared
)
1822 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1825 else if (!on
&& !cursor_cleared
)
1827 ScreenSetCursor (-1, -1);
1832 /* Emacs calls cursor-movement functions a lot when it updates the
1833 display (probably a legacy of old terminals where you cannot
1834 update a screen line without first moving the cursor there).
1835 However, cursor movement is expensive on MSDOS (it calls a slow
1836 BIOS function and requires 2 mode switches), while actual screen
1837 updates access the video memory directly and don't depend on
1838 cursor position. To avoid slowing down the redisplay, we cheat:
1839 all functions that move the cursor only set internal variables
1840 which record the cursor position, whereas the cursor is only
1841 moved to its final position whenever screen update is complete.
1843 `IT_cmgoto' is called from the keyboard reading loop and when the
1844 frame update is complete. This means that we are ready for user
1845 input, so we update the cursor position to show where the point is,
1846 and also make the mouse pointer visible.
1848 Special treatment is required when the cursor is in the echo area,
1849 to put the cursor at the end of the text displayed there. */
1852 IT_cmgoto (FRAME_PTR f
)
1854 /* Only set the cursor to where it should be if the display is
1855 already in sync with the window contents. */
1856 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1858 /* FIXME: This needs to be rewritten for the new redisplay, or
1861 static int previous_pos_X
= -1;
1863 update_cursor_pos
= 1; /* temporary!!! */
1865 /* If the display is in sync, forget any previous knowledge about
1866 cursor position. This is primarily for unexpected events like
1867 C-g in the minibuffer. */
1868 if (update_cursor_pos
&& previous_pos_X
>= 0)
1869 previous_pos_X
= -1;
1870 /* If we are in the echo area, put the cursor at the
1871 end of the echo area message. */
1872 if (!update_cursor_pos
1873 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1875 int tem_X
= current_pos_X
, dummy
;
1877 if (echo_area_glyphs
)
1879 tem_X
= echo_area_glyphs_length
;
1880 /* Save current cursor position, to be restored after the
1881 echo area message is erased. Only remember one level
1882 of previous cursor position. */
1883 if (previous_pos_X
== -1)
1884 ScreenGetCursor (&dummy
, &previous_pos_X
);
1886 else if (previous_pos_X
>= 0)
1888 /* We wind up here after the echo area message is erased.
1889 Restore the cursor position we remembered above. */
1890 tem_X
= previous_pos_X
;
1891 previous_pos_X
= -1;
1894 if (current_pos_X
!= tem_X
)
1897 update_cursor_pos
= 1;
1902 if (update_cursor_pos
1903 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1905 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1907 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1910 /* Maybe cursor is invisible, so make it visible. */
1911 IT_display_cursor (1);
1913 /* Mouse pointer should be always visible if we are waiting for
1920 IT_reassert_line_highlight (int new, int vpos
)
1926 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1928 highlight
= new_highlight
;
1929 IT_cursor_to (vpos
, 0);
1930 IT_clear_end_of_line (first_unused_hpos
);
1934 IT_update_begin (struct frame
*f
)
1936 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1937 struct frame
*mouse_face_frame
= display_info
->mouse_face_mouse_frame
;
1943 if (f
&& f
== mouse_face_frame
)
1945 /* Don't do highlighting for mouse motion during the update. */
1946 display_info
->mouse_face_defer
= 1;
1948 /* If F needs to be redrawn, simply forget about any prior mouse
1950 if (FRAME_GARBAGED_P (f
))
1951 display_info
->mouse_face_window
= Qnil
;
1953 /* Can we tell that this update does not affect the window
1954 where the mouse highlight is? If so, no need to turn off.
1955 Likewise, don't do anything if none of the enabled rows
1956 contains glyphs highlighted in mouse face. */
1957 if (!NILP (display_info
->mouse_face_window
)
1958 && WINDOWP (display_info
->mouse_face_window
))
1960 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1963 /* If the mouse highlight is in the window that was deleted
1964 (e.g., if it was popped by completion), clear highlight
1966 if (NILP (w
->buffer
))
1967 display_info
->mouse_face_window
= Qnil
;
1970 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1971 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1972 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1976 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1977 clear_mouse_face (display_info
);
1980 else if (mouse_face_frame
&& !FRAME_LIVE_P (mouse_face_frame
))
1982 /* If the frame with mouse highlight was deleted, invalidate the
1984 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1985 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1986 display_info
->mouse_face_window
= Qnil
;
1987 display_info
->mouse_face_deferred_gc
= 0;
1988 display_info
->mouse_face_mouse_frame
= NULL
;
1995 IT_update_end (struct frame
*f
)
1998 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
2001 Lisp_Object Qcursor_type
;
2004 IT_frame_up_to_date (struct frame
*f
)
2006 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2007 Lisp_Object new_cursor
, frame_desired_cursor
;
2010 if (dpyinfo
->mouse_face_deferred_gc
2011 || (f
&& f
== dpyinfo
->mouse_face_mouse_frame
))
2014 if (dpyinfo
->mouse_face_mouse_frame
)
2015 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2016 dpyinfo
->mouse_face_mouse_x
,
2017 dpyinfo
->mouse_face_mouse_y
);
2018 dpyinfo
->mouse_face_deferred_gc
= 0;
2022 /* Set the cursor type to whatever they wanted. In a minibuffer
2023 window, we want the cursor to appear only if we are reading input
2024 from this window, and we want the cursor to be taken from the
2025 frame parameters. For the selected window, we use either its
2026 buffer-local value or the value from the frame parameters if the
2027 buffer doesn't define its local value for the cursor type. */
2028 sw
= XWINDOW (f
->selected_window
);
2029 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2030 if (cursor_in_echo_area
2031 && FRAME_HAS_MINIBUF_P (f
)
2032 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2033 && sw
== XWINDOW (echo_area_window
))
2034 new_cursor
= frame_desired_cursor
;
2037 struct buffer
*b
= XBUFFER (sw
->buffer
);
2039 if (EQ (b
->cursor_type
, Qt
))
2040 new_cursor
= frame_desired_cursor
;
2041 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2042 new_cursor
= Fcons (Qbar
, make_number (0));
2044 new_cursor
= b
->cursor_type
;
2047 IT_set_cursor_type (f
, new_cursor
);
2049 IT_cmgoto (f
); /* position cursor when update is done */
2052 /* Copy LEN glyphs displayed on a single line whose vertical position
2053 is YPOS, beginning at horizontal position XFROM to horizontal
2054 position XTO, by moving blocks in the video memory. Used by
2055 functions that insert and delete glyphs. */
2057 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2059 /* The offsets of source and destination relative to the
2060 conventional memorty selector. */
2061 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2062 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2064 if (from
== to
|| len
<= 0)
2067 _farsetsel (_dos_ds
);
2069 /* The source and destination might overlap, so we need to move
2070 glyphs non-destructively. */
2073 for ( ; len
; from
+= 2, to
+= 2, len
--)
2074 _farnspokew (to
, _farnspeekw (from
));
2078 from
+= (len
- 1) * 2;
2079 to
+= (len
- 1) * 2;
2080 for ( ; len
; from
-= 2, to
-= 2, len
--)
2081 _farnspokew (to
, _farnspeekw (from
));
2083 if (screen_virtual_segment
)
2084 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2087 /* Insert and delete glyphs. */
2089 IT_insert_glyphs (start
, len
)
2090 register struct glyph
*start
;
2093 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2095 /* Shift right the glyphs from the nominal cursor position to the
2096 end of this line. */
2097 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2099 /* Now write the glyphs to be inserted. */
2100 IT_write_glyphs (start
, len
);
2104 IT_delete_glyphs (n
)
2110 /* set-window-configuration on window.c needs this. */
2112 x_set_menu_bar_lines (f
, value
, oldval
)
2114 Lisp_Object value
, oldval
;
2116 set_menu_bar_lines (f
, value
, oldval
);
2119 /* This was copied from xfaces.c */
2121 extern Lisp_Object Qbackground_color
;
2122 extern Lisp_Object Qforeground_color
;
2123 Lisp_Object Qreverse
;
2124 extern Lisp_Object Qtitle
;
2126 /* IT_set_terminal_modes is called when emacs is started,
2127 resumed, and whenever the screen is redrawn! */
2130 IT_set_terminal_modes (void)
2133 fprintf (termscript
, "\n<SET_TERM>");
2136 screen_size_X
= ScreenCols ();
2137 screen_size_Y
= ScreenRows ();
2138 screen_size
= screen_size_X
* screen_size_Y
;
2140 new_pos_X
= new_pos_Y
= 0;
2141 current_pos_X
= current_pos_Y
= -1;
2143 if (term_setup_done
)
2145 term_setup_done
= 1;
2147 startup_screen_size_X
= screen_size_X
;
2148 startup_screen_size_Y
= screen_size_Y
;
2149 startup_screen_attrib
= ScreenAttrib
;
2152 /* Is DOS/V (or any other RSIS software which relocates
2153 the screen) installed? */
2155 unsigned short es_value
;
2158 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2159 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2160 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2161 else if (screen_old_address
) /* already switched to Japanese mode once */
2162 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2164 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2166 es_value
= regs
.x
.es
;
2167 __dpmi_int (0x10, ®s
);
2169 if (regs
.x
.es
!= es_value
)
2171 /* screen_old_address is only set if ScreenPrimary does NOT
2172 already point to the relocated buffer address returned by
2173 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2174 ScreenPrimary to that address at startup under DOS/V. */
2175 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2176 screen_old_address
= ScreenPrimary
;
2177 screen_virtual_segment
= regs
.x
.es
;
2178 screen_virtual_offset
= regs
.x
.di
;
2179 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2182 #endif /* __DJGPP__ > 1 */
2184 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2185 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2188 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2189 screen_size_X
, screen_size_Y
);
2194 /* IT_reset_terminal_modes is called when emacs is
2195 suspended or killed. */
2198 IT_reset_terminal_modes (void)
2200 int display_row_start
= (int) ScreenPrimary
;
2201 int saved_row_len
= startup_screen_size_X
* 2;
2202 int update_row_len
= ScreenCols () * 2;
2203 int current_rows
= ScreenRows ();
2204 int to_next_row
= update_row_len
;
2205 unsigned char *saved_row
= startup_screen_buffer
;
2206 int cursor_pos_X
= ScreenCols () - 1;
2207 int cursor_pos_Y
= ScreenRows () - 1;
2210 fprintf (termscript
, "\n<RESET_TERM>");
2214 if (!term_setup_done
)
2219 /* Leave the video system in the same state as we found it,
2220 as far as the blink/bright-background bit is concerned. */
2221 maybe_enable_blinking ();
2223 /* We have a situation here.
2224 We cannot just do ScreenUpdate(startup_screen_buffer) because
2225 the luser could have changed screen dimensions inside Emacs
2226 and failed (or didn't want) to restore them before killing
2227 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2228 thus will happily use memory outside what was allocated for
2229 `startup_screen_buffer'.
2230 Thus we only restore as much as the current screen dimensions
2231 can hold, and clear the rest (if the saved screen is smaller than
2232 the current) with the color attribute saved at startup. The cursor
2233 is also restored within the visible dimensions. */
2235 ScreenAttrib
= startup_screen_attrib
;
2237 /* Don't restore the screen if we are exiting less than 2 seconds
2238 after startup: we might be crashing, and the screen might show
2239 some vital clues to what's wrong. */
2240 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2243 if (screen_virtual_segment
)
2244 dosv_refresh_virtual_screen (0, screen_size
);
2246 if (update_row_len
> saved_row_len
)
2247 update_row_len
= saved_row_len
;
2248 if (current_rows
> startup_screen_size_Y
)
2249 current_rows
= startup_screen_size_Y
;
2252 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2253 update_row_len
/ 2, current_rows
);
2255 while (current_rows
--)
2257 dosmemput (saved_row
, update_row_len
, display_row_start
);
2258 if (screen_virtual_segment
)
2259 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2260 update_row_len
/ 2);
2261 saved_row
+= saved_row_len
;
2262 display_row_start
+= to_next_row
;
2265 if (startup_pos_X
< cursor_pos_X
)
2266 cursor_pos_X
= startup_pos_X
;
2267 if (startup_pos_Y
< cursor_pos_Y
)
2268 cursor_pos_Y
= startup_pos_Y
;
2270 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2271 xfree (startup_screen_buffer
);
2273 term_setup_done
= 0;
2277 IT_set_terminal_window (int foo
)
2281 /* Remember the screen colors of the curent frame, to serve as the
2282 default colors for newly-created frames. */
2284 static int initial_screen_colors
[2];
2286 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2287 Smsdos_remember_default_colors
, 1, 1, 0,
2288 "Remember the screen colors of the current frame.")
2294 CHECK_FRAME (frame
, 0);
2297 initial_screen_colors
[0] = FRAME_FOREGROUND_PIXEL (f
);
2298 initial_screen_colors
[1] = FRAME_BACKGROUND_PIXEL (f
);
2302 IT_set_frame_parameters (f
, alist
)
2307 int length
= XINT (Flength (alist
));
2310 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2312 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2313 /* Do we have to reverse the foreground and background colors? */
2314 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2315 int was_reverse
= reverse
;
2316 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2317 int need_to_reverse
;
2318 unsigned long orig_fg
;
2319 unsigned long orig_bg
;
2320 Lisp_Object frame_bg
, frame_fg
;
2321 extern Lisp_Object Qdefault
, QCforeground
, QCbackground
;
2323 /* If we are creating a new frame, begin with the original screen colors
2324 used for the initial frame. */
2325 if (alist
== Vdefault_frame_alist
2326 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2328 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2329 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2331 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2332 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2333 frame_fg
= Fcdr (Fassq (Qforeground_color
, f
->param_alist
));
2334 frame_bg
= Fcdr (Fassq (Qbackground_color
, f
->param_alist
));
2335 /* frame_fg and frame_bg could be nil if, for example,
2336 f->param_alist is nil, e.g. if we are called from
2337 Fmake_terminal_frame. */
2338 if (NILP (frame_fg
))
2339 frame_fg
= build_string (unspecified_fg
);
2340 if (NILP (frame_bg
))
2341 frame_bg
= build_string (unspecified_bg
);
2343 /* Extract parm names and values into those vectors. */
2345 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2350 parms
[i
] = Fcar (elt
);
2351 CHECK_SYMBOL (parms
[i
], 1);
2352 values
[i
] = Fcdr (elt
);
2358 for (i
= 0; i
< j
; i
++)
2360 Lisp_Object prop
, val
;
2365 if (EQ (prop
, Qreverse
))
2366 reverse
= EQ (val
, Qt
);
2369 need_to_reverse
= reverse
&& !was_reverse
;
2370 if (termscript
&& need_to_reverse
)
2371 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2373 /* Now process the alist elements in reverse of specified order. */
2374 for (i
--; i
>= 0; i
--)
2376 Lisp_Object prop
, val
;
2382 if (EQ (prop
, Qforeground_color
))
2384 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2385 ? LFACE_BACKGROUND_INDEX
2386 : LFACE_FOREGROUND_INDEX
);
2387 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2388 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2389 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2391 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2392 /* Make sure the foreground of the default face for this
2393 frame is changed as well. */
2394 XSETFRAME (frame
, f
);
2395 if (need_to_reverse
)
2397 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2399 prop
= Qbackground_color
;
2403 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2409 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2412 else if (EQ (prop
, Qbackground_color
))
2414 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2415 ? LFACE_FOREGROUND_INDEX
2416 : LFACE_BACKGROUND_INDEX
);
2417 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2418 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2419 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2421 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2422 /* Make sure the background of the default face for this
2423 frame is changed as well. */
2424 XSETFRAME (frame
, f
);
2425 if (need_to_reverse
)
2427 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2429 prop
= Qforeground_color
;
2433 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2439 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2442 else if (EQ (prop
, Qtitle
))
2444 x_set_title (f
, val
);
2446 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2448 else if (EQ (prop
, Qcursor_type
))
2450 IT_set_cursor_type (f
, val
);
2452 fprintf (termscript
, "<CTYPE: %s>\n",
2453 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2456 store_frame_param (f
, prop
, val
);
2459 /* If they specified "reverse", but not the colors, we need to swap
2460 the current frame colors. */
2461 if (need_to_reverse
)
2467 XSETFRAME (frame
, f
);
2468 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2469 tty_color_name (f
, orig_fg
),
2471 store_frame_param (f
, Qbackground_color
, frame_fg
);
2476 XSETFRAME (frame
, f
);
2477 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2478 tty_color_name (f
, orig_bg
),
2480 store_frame_param (f
, Qforeground_color
, frame_bg
);
2487 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2488 if (f
== SELECTED_FRAME())
2493 extern void init_frame_faces (FRAME_PTR
);
2495 #endif /* !HAVE_X_WINDOWS */
2498 /* Do we need the internal terminal? */
2501 internal_terminal_init ()
2503 char *term
= getenv ("TERM");
2505 struct frame
*sf
= SELECTED_FRAME();
2507 #ifdef HAVE_X_WINDOWS
2508 if (!inhibit_window_system
)
2513 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2515 if (getenv ("EMACSTEST"))
2516 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2518 #ifndef HAVE_X_WINDOWS
2519 if (!internal_terminal
|| inhibit_window_system
)
2521 sf
->output_method
= output_termcap
;
2525 Vwindow_system
= intern ("pc");
2526 Vwindow_system_version
= make_number (1);
2527 sf
->output_method
= output_msdos_raw
;
2529 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2530 screen_old_address
= 0;
2532 /* Forget the stale screen colors as well. */
2533 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2535 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2536 the_only_x_display
.background_pixel
= 7; /* White */
2537 the_only_x_display
.foreground_pixel
= 0; /* Black */
2539 colors
= getenv ("EMACSCOLORS");
2540 if (colors
&& strlen (colors
) >= 2)
2542 /* The colors use 4 bits each (we enable bright background). */
2543 if (isdigit (colors
[0]))
2545 else if (isxdigit (colors
[0]))
2546 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2547 if (colors
[0] >= 0 && colors
[0] < 16)
2548 the_only_x_display
.foreground_pixel
= colors
[0];
2549 if (isdigit (colors
[1]))
2551 else if (isxdigit (colors
[1]))
2552 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2553 if (colors
[1] >= 0 && colors
[1] < 16)
2554 the_only_x_display
.background_pixel
= colors
[1];
2556 the_only_x_display
.line_height
= 1;
2557 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2558 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2559 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2560 the_only_x_display
.display_info
.mouse_face_beg_row
=
2561 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2562 the_only_x_display
.display_info
.mouse_face_end_row
=
2563 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2564 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2565 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2566 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2567 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2568 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2570 init_frame_faces (sf
);
2572 ring_bell_hook
= IT_ring_bell
;
2573 insert_glyphs_hook
= IT_insert_glyphs
;
2574 delete_glyphs_hook
= IT_delete_glyphs
;
2575 write_glyphs_hook
= IT_write_glyphs
;
2576 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2577 clear_to_end_hook
= IT_clear_to_end
;
2578 clear_end_of_line_hook
= IT_clear_end_of_line
;
2579 clear_frame_hook
= IT_clear_screen
;
2580 change_line_highlight_hook
= IT_change_line_highlight
;
2581 update_begin_hook
= IT_update_begin
;
2582 update_end_hook
= IT_update_end
;
2583 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2584 frame_up_to_date_hook
= IT_frame_up_to_date
;
2586 /* These hooks are called by term.c without being checked. */
2587 set_terminal_modes_hook
= IT_set_terminal_modes
;
2588 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2589 set_terminal_window_hook
= IT_set_terminal_window
;
2590 char_ins_del_ok
= 0;
2594 dos_get_saved_screen (screen
, rows
, cols
)
2599 #ifndef HAVE_X_WINDOWS
2600 *screen
= startup_screen_buffer
;
2601 *cols
= startup_screen_size_X
;
2602 *rows
= startup_screen_size_Y
;
2603 return *screen
!= (char *)0;
2609 #ifndef HAVE_X_WINDOWS
2611 /* We are not X, but we can emulate it well enough for our needs... */
2615 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2616 error ("Not running under a window system");
2622 /* ----------------------- Keyboard control ----------------------
2624 * Keymaps reflect the following keyboard layout:
2626 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2627 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2628 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2629 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2633 #define Ignore 0x0000
2634 #define Normal 0x0000 /* normal key - alt changes scan-code */
2635 #define FctKey 0x1000 /* func key if c == 0, else c */
2636 #define Special 0x2000 /* func key even if c != 0 */
2637 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2638 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2639 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2640 #define Grey 0x6000 /* Grey keypad key */
2642 #define Alt 0x0100 /* alt scan-code */
2643 #define Ctrl 0x0200 /* ctrl scan-code */
2644 #define Shift 0x0400 /* shift scan-code */
2646 static int extended_kbd
; /* 101 (102) keyboard present. */
2648 struct kbd_translate
{
2651 unsigned short code
;
2654 struct dos_keyboard_map
2659 struct kbd_translate
*translate_table
;
2663 static struct dos_keyboard_map us_keyboard
= {
2665 /* 01234567890123456789012345678901234567890 12345678901234 */
2666 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2667 /* 0123456789012345678901234567890123456789 012345678901234 */
2668 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2669 0, /* no Alt-Gr key */
2670 0 /* no translate table */
2673 static struct dos_keyboard_map fr_keyboard
= {
2675 /* 012 3456789012345678901234567890123456789012345678901234 */
2676 "ý&‚\",(-Š_€…)= azertyuiop^$ qsdfghjklm—* wxcvbnm;:! ",
2677 /* 0123456789012345678901234567890123456789012345678901234 */
2678 " 1234567890ø+ AZERTYUIOPùœ QSDFGHJKLM%æ WXCVBN?./õ ",
2679 /* 01234567 89012345678901234567890123456789012345678901234 */
2681 0 /* no translate table */
2685 * Italian keyboard support, country code 39.
2688 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2689 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2692 static struct kbd_translate it_kbd_translate_table
[] = {
2693 { 0x56, 0x3c, Normal
| 13 },
2694 { 0x56, 0x3e, Normal
| 27 },
2697 static struct dos_keyboard_map it_keyboard
= {
2699 /* 0 123456789012345678901234567890123456789012345678901234 */
2700 "\\1234567890'�< qwertyuiopŠ+> asdfghjkl•…— zxcvbnm,.- ",
2701 /* 01 23456789012345678901234567890123456789012345678901234 */
2702 "|!\"œ$%&/()=?^> QWERTYUIOP‚* ASDFGHJKL‡øõ ZXCVBNM;:_ ",
2703 /* 0123456789012345678901234567890123456789012345678901234 */
2705 it_kbd_translate_table
2708 static struct dos_keyboard_map dk_keyboard
= {
2710 /* 0123456789012345678901234567890123456789012345678901234 */
2711 "«1234567890+| qwertyuiop†~ asdfghjkl‘›' zxcvbnm,.- ",
2712 /* 01 23456789012345678901234567890123456789012345678901234 */
2713 "õ!\"#$%&/()=?` QWERTYUIOP�^ ASDFGHJKL’�* ZXCVBNM;:_ ",
2714 /* 0123456789012345678901234567890123456789012345678901234 */
2716 0 /* no translate table */
2719 static struct kbd_translate jp_kbd_translate_table
[] = {
2720 { 0x73, 0x5c, Normal
| 0 },
2721 { 0x73, 0x5f, Normal
| 0 },
2722 { 0x73, 0x1c, Map
| 0 },
2723 { 0x7d, 0x5c, Normal
| 13 },
2724 { 0x7d, 0x7c, Normal
| 13 },
2725 { 0x7d, 0x1c, Map
| 13 },
2728 static struct dos_keyboard_map jp_keyboard
= {
2730 /* 0123456789012 345678901234567890123456789012345678901234 */
2731 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2732 /* 01 23456789012345678901234567890123456789012345678901234 */
2733 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2734 0, /* no Alt-Gr key */
2735 jp_kbd_translate_table
2738 static struct keyboard_layout_list
2741 struct dos_keyboard_map
*keyboard_map
;
2742 } keyboard_layout_list
[] =
2751 static struct dos_keyboard_map
*keyboard
;
2752 static int keyboard_map_all
;
2753 static int international_keyboard
;
2756 dos_set_keyboard (code
, always
)
2761 _go32_dpmi_registers regs
;
2763 /* See if Keyb.Com is installed (for international keyboard support).
2764 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2765 of Windows 9X! So don't do that! */
2767 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2768 _go32_dpmi_simulate_int (0x2f, ®s
);
2769 if (regs
.h
.al
== 0xff)
2770 international_keyboard
= 1;
2772 /* Initialize to US settings, for countries that don't have their own. */
2773 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2774 keyboard_map_all
= always
;
2775 dos_keyboard_layout
= 1;
2777 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2778 if (code
== keyboard_layout_list
[i
].country_code
)
2780 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2781 keyboard_map_all
= always
;
2782 dos_keyboard_layout
= code
;
2790 unsigned char char_code
; /* normal code */
2791 unsigned char meta_code
; /* M- code */
2792 unsigned char keypad_code
; /* keypad code */
2793 unsigned char editkey_code
; /* edit key */
2794 } keypad_translate_map
[] = {
2795 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2796 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2797 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2798 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2799 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2800 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2801 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2802 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2803 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2804 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2805 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2810 unsigned char char_code
; /* normal code */
2811 unsigned char keypad_code
; /* keypad code */
2812 } grey_key_translate_map
[] = {
2813 '/', 0xaf, /* kp-decimal */
2814 '*', 0xaa, /* kp-multiply */
2815 '-', 0xad, /* kp-subtract */
2816 '+', 0xab, /* kp-add */
2817 '\r', 0x8d /* kp-enter */
2820 static unsigned short
2821 ibmpc_translate_map
[] =
2823 /* --------------- 00 to 0f --------------- */
2824 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2825 Alt
| ModFct
| 0x1b, /* Escape */
2826 Normal
| 1, /* '1' */
2827 Normal
| 2, /* '2' */
2828 Normal
| 3, /* '3' */
2829 Normal
| 4, /* '4' */
2830 Normal
| 5, /* '5' */
2831 Normal
| 6, /* '6' */
2832 Normal
| 7, /* '7' */
2833 Normal
| 8, /* '8' */
2834 Normal
| 9, /* '9' */
2835 Normal
| 10, /* '0' */
2836 Normal
| 11, /* '-' */
2837 Normal
| 12, /* '=' */
2838 Special
| 0x08, /* Backspace */
2839 ModFct
| 0x74, /* Tab/Backtab */
2841 /* --------------- 10 to 1f --------------- */
2854 ModFct
| 0x0d, /* Return */
2859 /* --------------- 20 to 2f --------------- */
2868 Map
| 40, /* '\'' */
2870 Ignore
, /* Left shift */
2871 Map
| 41, /* '\\' */
2877 /* --------------- 30 to 3f --------------- */
2884 Ignore
, /* Right shift */
2885 Grey
| 1, /* Grey * */
2887 Normal
| 55, /* ' ' */
2888 Ignore
, /* Caps Lock */
2889 FctKey
| 0xbe, /* F1 */
2890 FctKey
| 0xbf, /* F2 */
2891 FctKey
| 0xc0, /* F3 */
2892 FctKey
| 0xc1, /* F4 */
2893 FctKey
| 0xc2, /* F5 */
2895 /* --------------- 40 to 4f --------------- */
2896 FctKey
| 0xc3, /* F6 */
2897 FctKey
| 0xc4, /* F7 */
2898 FctKey
| 0xc5, /* F8 */
2899 FctKey
| 0xc6, /* F9 */
2900 FctKey
| 0xc7, /* F10 */
2901 Ignore
, /* Num Lock */
2902 Ignore
, /* Scroll Lock */
2903 KeyPad
| 7, /* Home */
2904 KeyPad
| 8, /* Up */
2905 KeyPad
| 9, /* Page Up */
2906 Grey
| 2, /* Grey - */
2907 KeyPad
| 4, /* Left */
2908 KeyPad
| 5, /* Keypad 5 */
2909 KeyPad
| 6, /* Right */
2910 Grey
| 3, /* Grey + */
2911 KeyPad
| 1, /* End */
2913 /* --------------- 50 to 5f --------------- */
2914 KeyPad
| 2, /* Down */
2915 KeyPad
| 3, /* Page Down */
2916 KeyPad
| 0, /* Insert */
2917 KeyPad
| 10, /* Delete */
2918 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2919 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2920 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2921 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2922 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2923 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2924 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2925 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2926 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2927 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2928 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2929 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2931 /* --------------- 60 to 6f --------------- */
2932 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2933 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2934 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2935 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2936 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2937 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2938 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2939 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2940 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2941 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2942 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2943 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2944 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2945 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2946 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2947 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2949 /* --------------- 70 to 7f --------------- */
2950 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2951 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2952 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2953 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2954 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2955 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2956 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2957 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2958 Alt
| Map
| 1, /* '1' */
2959 Alt
| Map
| 2, /* '2' */
2960 Alt
| Map
| 3, /* '3' */
2961 Alt
| Map
| 4, /* '4' */
2962 Alt
| Map
| 5, /* '5' */
2963 Alt
| Map
| 6, /* '6' */
2964 Alt
| Map
| 7, /* '7' */
2965 Alt
| Map
| 8, /* '8' */
2967 /* --------------- 80 to 8f --------------- */
2968 Alt
| Map
| 9, /* '9' */
2969 Alt
| Map
| 10, /* '0' */
2970 Alt
| Map
| 11, /* '-' */
2971 Alt
| Map
| 12, /* '=' */
2972 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2973 FctKey
| 0xc8, /* F11 */
2974 FctKey
| 0xc9, /* F12 */
2975 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2976 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2977 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2978 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2979 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2980 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2981 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2982 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2983 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2985 /* --------------- 90 to 9f --------------- */
2986 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2987 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2988 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2989 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2990 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2991 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2992 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2993 Alt
| FctKey
| 0x50, /* (Alt) Home */
2994 Alt
| FctKey
| 0x52, /* (Alt) Up */
2995 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2996 Ignore
, /* NO KEY */
2997 Alt
| FctKey
| 0x51, /* (Alt) Left */
2998 Ignore
, /* NO KEY */
2999 Alt
| FctKey
| 0x53, /* (Alt) Right */
3000 Ignore
, /* NO KEY */
3001 Alt
| FctKey
| 0x57, /* (Alt) End */
3003 /* --------------- a0 to af --------------- */
3004 Alt
| KeyPad
| 2, /* (Alt) Down */
3005 Alt
| KeyPad
| 3, /* (Alt) Page Down */
3006 Alt
| KeyPad
| 0, /* (Alt) Insert */
3007 Alt
| KeyPad
| 10, /* (Alt) Delete */
3008 Alt
| Grey
| 0, /* (Alt) Grey / */
3009 Alt
| FctKey
| 0x09, /* (Alt) Tab */
3010 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
3013 /* These bit-positions corresponds to values returned by BIOS */
3014 #define SHIFT_P 0x0003 /* two bits! */
3015 #define CTRL_P 0x0004
3016 #define ALT_P 0x0008
3017 #define SCRLOCK_P 0x0010
3018 #define NUMLOCK_P 0x0020
3019 #define CAPSLOCK_P 0x0040
3020 #define ALT_GR_P 0x0800
3021 #define SUPER_P 0x4000 /* pseudo */
3022 #define HYPER_P 0x8000 /* pseudo */
3025 dos_get_modifiers (keymask
)
3032 /* Calculate modifier bits */
3033 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
3034 int86 (0x16, ®s
, ®s
);
3038 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
3039 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3043 mask
= regs
.h
.al
& (SHIFT_P
|
3044 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3046 /* Do not break international keyboard support. */
3047 /* When Keyb.Com is loaded, the right Alt key is */
3048 /* used for accessing characters like { and } */
3049 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
3052 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
3055 if (dos_hyper_key
== 1)
3058 modifiers
|= hyper_modifier
;
3060 else if (dos_super_key
== 1)
3063 modifiers
|= super_modifier
;
3065 else if (!international_keyboard
)
3067 /* If Keyb.Com is NOT installed, let Right Alt behave
3068 like the Left Alt. */
3074 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3077 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3079 if (dos_hyper_key
== 2)
3082 modifiers
|= hyper_modifier
;
3084 else if (dos_super_key
== 2)
3087 modifiers
|= super_modifier
;
3095 modifiers
|= shift_modifier
;
3097 modifiers
|= ctrl_modifier
;
3099 modifiers
|= meta_modifier
;
3106 #define NUM_RECENT_DOSKEYS (100)
3107 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3108 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3109 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3111 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3112 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3113 Each input key receives two values in this vector: first the ASCII code,\n\
3114 and then the scan code.")
3117 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3120 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3121 return Fvector (total_doskeys
, keys
);
3124 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3125 bcopy (keys
+ recent_doskeys_index
,
3126 XVECTOR (val
)->contents
,
3127 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3129 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3130 recent_doskeys_index
* sizeof (Lisp_Object
));
3135 /* Get a char from keyboard. Function keys are put into the event queue. */
3139 struct input_event event
;
3142 #ifndef HAVE_X_WINDOWS
3143 /* Maybe put the cursor where it should be. */
3144 IT_cmgoto (SELECTED_FRAME());
3147 /* The following condition is equivalent to `kbhit ()', except that
3148 it uses the bios to do its job. This pleases DESQview/X. */
3149 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3150 int86 (0x16, ®s
, ®s
),
3151 (regs
.x
.flags
& 0x40) == 0)
3154 register unsigned char c
;
3155 int sc
, code
= -1, mask
, kp_mode
;
3158 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3159 int86 (0x16, ®s
, ®s
);
3164 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3166 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3167 recent_doskeys_index
= 0;
3168 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3170 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3171 recent_doskeys_index
= 0;
3173 modifiers
= dos_get_modifiers (&mask
);
3175 #ifndef HAVE_X_WINDOWS
3176 if (!NILP (Vdos_display_scancodes
))
3179 sprintf (buf
, "%02x:%02x*%04x",
3180 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3181 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3189 case 10: /* Ctrl Grey Enter */
3190 code
= Ctrl
| Grey
| 4;
3192 case 13: /* Grey Enter */
3195 case '/': /* Grey / */
3205 /* Try the keyboard-private translation table first. */
3206 if (keyboard
->translate_table
)
3208 struct kbd_translate
*p
= keyboard
->translate_table
;
3212 if (p
->sc
== sc
&& p
->ch
== c
)
3220 /* If the private table didn't translate it, use the general
3224 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3226 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3233 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3234 Emacs is ready to read a key. Therefore, if they press
3235 `Alt-x' when Emacs is busy, by the time we get to
3236 `dos_get_modifiers', they might have already released the
3237 Alt key, and Emacs gets just `x', which is BAD.
3238 However, for keys with the `Map' property set, the ASCII
3239 code returns zero iff Alt is pressed. So, when we DON'T
3240 have to support international_keyboard, we don't have to
3241 distinguish between the left and right Alt keys, and we
3242 can set the META modifier for any keys with the `Map'
3243 property if they return zero ASCII code (c = 0). */
3245 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3246 modifiers
|= meta_modifier
;
3248 modifiers
|= ctrl_modifier
;
3250 modifiers
|= shift_modifier
;
3253 switch (code
& 0xf000)
3256 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3258 c
= 0; /* Special */
3271 if (c
== 0) /* ctrl-break */
3273 return c
; /* ALT-nnn */
3275 if (!keyboard_map_all
)
3284 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3285 if (!keyboard_map_all
)
3289 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3290 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3294 code
= keyboard
->shifted
[code
];
3296 modifiers
&= ~shift_modifier
;
3299 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3300 code
= keyboard
->alt_gr
[code
];
3302 code
= keyboard
->unshifted
[code
];
3307 if (c
== 0xe0) /* edit key */
3310 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3311 kp_mode
= dos_keypad_mode
& 0x03;
3313 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3318 if (code
== 10 && dos_decimal_point
)
3319 return dos_decimal_point
;
3320 return keypad_translate_map
[code
].char_code
;
3323 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3327 code
= keypad_translate_map
[code
].meta_code
;
3328 modifiers
= meta_modifier
;
3332 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3339 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3340 if (dos_keypad_mode
& kp_mode
)
3341 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3343 code
= grey_key_translate_map
[code
].char_code
;
3352 event
.kind
= non_ascii_keystroke
;
3354 event
.kind
= ascii_keystroke
;
3356 event
.modifiers
= modifiers
;
3357 event
.frame_or_window
= selected_frame
;
3359 event
.timestamp
= event_timestamp ();
3360 kbd_buffer_store_event (&event
);
3363 if (have_mouse
> 0 && !mouse_preempted
)
3365 int but
, press
, x
, y
, ok
;
3366 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3368 /* Check for mouse movement *before* buttons. */
3369 mouse_check_moved ();
3371 /* If the mouse moved from the spot of its last sighting, we
3372 might need to update mouse highlight. */
3373 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3375 previous_help_echo
= help_echo
;
3376 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3378 IT_note_mouse_highlight (SELECTED_FRAME(),
3379 mouse_last_x
, mouse_last_y
);
3380 /* If the contents of the global variable help_echo has
3381 changed, generate a HELP_EVENT. */
3382 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3384 /* HELP_EVENT takes 2 events in the event loop. */
3385 event
.kind
= HELP_EVENT
;
3386 event
.frame_or_window
= selected_frame
;
3387 event
.arg
= help_echo_object
;
3388 event
.x
= make_number (help_echo_pos
);
3389 event
.timestamp
= event_timestamp ();
3391 kbd_buffer_store_event (&event
);
3392 if (WINDOWP (help_echo_window
))
3393 event
.frame_or_window
= help_echo_window
;
3394 event
.arg
= help_echo
;
3396 kbd_buffer_store_event (&event
);
3400 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3401 for (press
= 0; press
< 2; press
++)
3403 int button_num
= but
;
3406 ok
= mouse_pressed (but
, &x
, &y
);
3408 ok
= mouse_released (but
, &x
, &y
);
3411 /* Allow a simultaneous press/release of Mouse-1 and
3412 Mouse-2 to simulate Mouse-3 on two-button mice. */
3413 if (mouse_button_count
== 2 && but
< 2)
3415 int x2
, y2
; /* don't clobber original coordinates */
3417 /* If only one button is pressed, wait 100 msec and
3418 check again. This way, Speedy Gonzales isn't
3419 punished, while the slow get their chance. */
3420 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3421 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3426 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3427 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3432 event
.kind
= mouse_click
;
3433 event
.code
= button_num
;
3434 event
.modifiers
= dos_get_modifiers (0)
3435 | (press
? down_modifier
: up_modifier
);
3438 event
.frame_or_window
= selected_frame
;
3440 event
.timestamp
= event_timestamp ();
3441 kbd_buffer_store_event (&event
);
3449 static int prev_get_char
= -1;
3451 /* Return 1 if a key is ready to be read without suspending execution. */
3455 if (prev_get_char
!= -1)
3458 return ((prev_get_char
= dos_rawgetc ()) != -1);
3461 /* Read a key. Return -1 if no key is ready. */
3465 if (prev_get_char
!= -1)
3467 int c
= prev_get_char
;
3472 return dos_rawgetc ();
3475 #ifndef HAVE_X_WINDOWS
3476 /* See xterm.c for more info. */
3478 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3480 register int pix_x
, pix_y
;
3481 register int *x
, *y
;
3485 if (bounds
) abort ();
3487 /* Ignore clipping. */
3494 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3497 register int *pix_x
, *pix_y
;
3503 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3506 Actually, I don't know the meaning of all the parameters of the functions
3507 here -- I only know how they are called by xmenu.c. I could of course
3508 grab the nearest Xlib manual (down the hall, second-to-last door on the
3509 left), but I don't think it's worth the effort. */
3511 /* These hold text of the current and the previous menu help messages. */
3512 static char *menu_help_message
, *prev_menu_help_message
;
3513 /* Pane number and item number of the menu item which generated the
3514 last menu help message. */
3515 static int menu_help_paneno
, menu_help_itemno
;
3522 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3523 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3527 /* Allocate some (more) memory for MENU ensuring that there is room for one
3531 IT_menu_make_room (XMenu
*menu
)
3533 if (menu
->allocated
== 0)
3535 int count
= menu
->allocated
= 10;
3536 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3537 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3538 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3539 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3541 else if (menu
->allocated
== menu
->count
)
3543 int count
= menu
->allocated
= menu
->allocated
+ 10;
3545 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3547 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3549 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3551 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3555 /* Search the given menu structure for a given pane number. */
3558 IT_menu_search_pane (XMenu
*menu
, int pane
)
3563 for (i
= 0; i
< menu
->count
; i
++)
3564 if (menu
->submenu
[i
])
3566 if (pane
== menu
->panenumber
[i
])
3567 return menu
->submenu
[i
];
3568 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3574 /* Determine how much screen space a given menu needs. */
3577 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3579 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3582 maxheight
= menu
->count
;
3583 for (i
= 0; i
< menu
->count
; i
++)
3585 if (menu
->submenu
[i
])
3587 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3588 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3589 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3592 *width
= menu
->width
+ maxsubwidth
;
3593 *height
= maxheight
;
3596 /* Display MENU at (X,Y) using FACES. */
3599 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3601 int i
, j
, face
, width
;
3602 struct glyph
*text
, *p
;
3605 int enabled
, mousehere
;
3607 struct frame
*sf
= SELECTED_FRAME();
3609 menu_help_message
= NULL
;
3611 width
= menu
->width
;
3612 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3613 ScreenGetCursor (&row
, &col
);
3614 mouse_get_xy (&mx
, &my
);
3615 IT_update_begin (sf
);
3616 for (i
= 0; i
< menu
->count
; i
++)
3618 int max_width
= width
+ 2;
3620 IT_cursor_to (y
+ i
, x
);
3622 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3623 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3624 face
= faces
[enabled
+ mousehere
* 2];
3625 /* The following if clause means that we display the menu help
3626 strings even if the menu item is currently disabled. */
3627 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3629 menu_help_message
= menu
->help_text
[i
];
3630 menu_help_paneno
= pn
- 1;
3631 menu_help_itemno
= i
;
3634 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3636 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3640 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3643 else /* make '^x' */
3645 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3648 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3652 /* Don't let the menu text overflow into the next screen row. */
3653 if (x
+ max_width
> screen_size_X
)
3655 max_width
= screen_size_X
- x
;
3656 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3658 for (; j
< max_width
- 2; j
++, p
++)
3659 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3661 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3663 IT_write_glyphs (text
, max_width
);
3666 IT_cursor_to (row
, col
);
3670 /* --------------------------- X Menu emulation ---------------------- */
3672 /* Report availability of menus. */
3680 /* Create a brand new menu structure. */
3683 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3685 return IT_menu_create ();
3688 /* Create a new pane and place it on the outer-most level. It is not
3689 clear that it should be placed out there, but I don't know what else
3693 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3701 IT_menu_make_room (menu
);
3702 menu
->submenu
[menu
->count
] = IT_menu_create ();
3703 menu
->text
[menu
->count
] = txt
;
3704 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3705 menu
->help_text
[menu
->count
] = NULL
;
3708 /* Adjust length for possible control characters (which will
3709 be written as ^x). */
3710 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3714 if (len
> menu
->width
)
3717 return menu
->panecount
;
3720 /* Create a new item in a menu pane. */
3723 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3724 int foo
, char *txt
, int enable
, char *help_text
)
3730 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3732 IT_menu_make_room (menu
);
3733 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3734 menu
->text
[menu
->count
] = txt
;
3735 menu
->panenumber
[menu
->count
] = enable
;
3736 menu
->help_text
[menu
->count
] = help_text
;
3739 /* Adjust length for possible control characters (which will
3740 be written as ^x). */
3741 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3745 if (len
> menu
->width
)
3751 /* Decide where the menu would be placed if requested at (X,Y). */
3754 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3755 int *ulx
, int *uly
, int *width
, int *height
)
3757 IT_menu_calc_size (menu
, width
, height
);
3763 struct IT_menu_state
3765 void *screen_behind
;
3772 /* Display menu, wait for user's response, and return that response. */
3775 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3776 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3777 void (*help_callback
)(char *, int, int))
3779 struct IT_menu_state
*state
;
3784 Lisp_Object selectface
;
3785 int leave
, result
, onepane
;
3786 int title_faces
[4]; /* face to display the menu title */
3787 int buffers_num_deleted
= 0;
3788 struct frame
*sf
= SELECTED_FRAME();
3789 Lisp_Object saved_echo_area_message
;
3791 /* Just in case we got here without a mouse present... */
3792 if (have_mouse
<= 0)
3793 return XM_IA_SELECT
;
3794 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3795 around the display. */
3801 /* We will process all the mouse events directly, so we had
3802 better prevent dos_rawgetc from stealing them from us. */
3805 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3806 screensize
= screen_size
* 2;
3808 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3809 0, DEFAULT_FACE_ID
);
3811 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3812 0, DEFAULT_FACE_ID
);
3813 selectface
= intern ("msdos-menu-select-face");
3814 faces
[2] = lookup_derived_face (sf
, selectface
,
3816 faces
[3] = lookup_derived_face (sf
, selectface
,
3819 /* Make sure the menu title is always displayed with
3820 `msdos-menu-active-face', no matter where the mouse pointer is. */
3821 for (i
= 0; i
< 4; i
++)
3822 title_faces
[i
] = faces
[3];
3826 /* Don't let the title for the "Buffers" popup menu include a
3827 digit (which is ugly).
3829 This is a terrible kludge, but I think the "Buffers" case is
3830 the only one where the title includes a number, so it doesn't
3831 seem to be necessary to make this more general. */
3832 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3834 menu
->text
[0][7] = '\0';
3835 buffers_num_deleted
= 1;
3838 /* We need to save the current echo area message, so that we could
3839 restore it below, before we exit. See the commentary below,
3840 before the call to message_with_string. */
3841 saved_echo_area_message
= Fcurrent_message ();
3842 state
[0].menu
= menu
;
3844 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3846 /* Turn off the cursor. Otherwise it shows through the menu
3847 panes, which is ugly. */
3848 IT_display_cursor (0);
3850 /* Display the menu title. */
3851 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3852 if (buffers_num_deleted
)
3853 menu
->text
[0][7] = ' ';
3854 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3856 menu
->width
= menu
->submenu
[0]->width
;
3857 state
[0].menu
= menu
->submenu
[0];
3861 state
[0].menu
= menu
;
3863 state
[0].x
= x0
- 1;
3865 state
[0].pane
= onepane
;
3867 mouse_last_x
= -1; /* A hack that forces display. */
3871 if (!mouse_visible
) mouse_on ();
3872 mouse_check_moved ();
3873 if (sf
->mouse_moved
)
3875 sf
->mouse_moved
= 0;
3876 result
= XM_IA_SELECT
;
3877 mouse_get_xy (&x
, &y
);
3878 for (i
= 0; i
< statecount
; i
++)
3879 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3881 int dy
= y
- state
[i
].y
;
3882 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3884 if (!state
[i
].menu
->submenu
[dy
])
3885 if (state
[i
].menu
->panenumber
[dy
])
3886 result
= XM_SUCCESS
;
3888 result
= XM_IA_SELECT
;
3889 *pane
= state
[i
].pane
- 1;
3891 /* We hit some part of a menu, so drop extra menus that
3892 have been opened. That does not include an open and
3894 if (i
!= statecount
- 2
3895 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3896 while (i
!= statecount
- 1)
3900 ScreenUpdate (state
[statecount
].screen_behind
);
3901 if (screen_virtual_segment
)
3902 dosv_refresh_virtual_screen (0, screen_size
);
3903 xfree (state
[statecount
].screen_behind
);
3905 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3907 IT_menu_display (state
[i
].menu
,
3912 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3913 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3915 ScreenRetrieve (state
[statecount
].screen_behind
3916 = xmalloc (screensize
));
3918 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3919 state
[statecount
].y
= y
;
3924 IT_menu_display (state
[statecount
- 1].menu
,
3925 state
[statecount
- 1].y
,
3926 state
[statecount
- 1].x
,
3927 state
[statecount
- 1].pane
,
3932 if ((menu_help_message
|| prev_menu_help_message
)
3933 && menu_help_message
!= prev_menu_help_message
)
3935 help_callback (menu_help_message
,
3936 menu_help_paneno
, menu_help_itemno
);
3937 IT_display_cursor (0);
3938 prev_menu_help_message
= menu_help_message
;
3940 /* We are busy-waiting for the mouse to move, so let's be nice
3941 to other Windows applications by releasing our time slice. */
3944 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3946 /* Only leave if user both pressed and released the mouse, and in
3947 that order. This avoids popping down the menu pane unless
3948 the user is really done with it. */
3949 if (mouse_pressed (b
, &x
, &y
))
3951 while (mouse_button_depressed (b
, &x
, &y
))
3955 (void) mouse_released (b
, &x
, &y
);
3960 ScreenUpdate (state
[0].screen_behind
);
3961 if (screen_virtual_segment
)
3962 dosv_refresh_virtual_screen (0, screen_size
);
3964 /* We have a situation here. ScreenUpdate has just restored the
3965 screen contents as it was before we started drawing this menu.
3966 That includes any echo area message that could have been
3967 displayed back then. (In reality, that echo area message will
3968 almost always be the ``keystroke echo'' that echoes the sequence
3969 of menu items chosen by the user.) However, if the menu had some
3970 help messages, then displaying those messages caused Emacs to
3971 forget about the original echo area message. So when
3972 ScreenUpdate restored it, it created a discrepancy between the
3973 actual screen contents and what Emacs internal data structures
3976 To avoid this conflict, we force Emacs to restore the original
3977 echo area message as we found it when we entered this function.
3978 The irony of this is that we then erase the restored message
3979 right away, so the only purpose of restoring it is so that
3980 erasing it works correctly... */
3981 if (! NILP (saved_echo_area_message
))
3982 message_with_string ("%s", saved_echo_area_message
, 0);
3984 while (statecount
--)
3985 xfree (state
[statecount
].screen_behind
);
3986 IT_display_cursor (1); /* turn cursor back on */
3987 /* Clean up any mouse events that are waiting inside Emacs event queue.
3988 These events are likely to be generated before the menu was even
3989 displayed, probably because the user pressed and released the button
3990 (which invoked the menu) too quickly. If we don't remove these events,
3991 Emacs will process them after we return and surprise the user. */
3992 discard_mouse_events ();
3993 mouse_clear_clicks ();
3994 if (!kbd_buffer_events_waiting (1))
3995 clear_input_pending ();
3996 /* Allow mouse events generation by dos_rawgetc. */
4001 /* Dispose of a menu. */
4004 XMenuDestroy (Display
*foo
, XMenu
*menu
)
4007 if (menu
->allocated
)
4009 for (i
= 0; i
< menu
->count
; i
++)
4010 if (menu
->submenu
[i
])
4011 XMenuDestroy (foo
, menu
->submenu
[i
]);
4013 xfree (menu
->submenu
);
4014 xfree (menu
->panenumber
);
4015 xfree (menu
->help_text
);
4018 menu_help_message
= prev_menu_help_message
= NULL
;
4022 x_pixel_width (struct frame
*f
)
4024 return FRAME_WIDTH (f
);
4028 x_pixel_height (struct frame
*f
)
4030 return FRAME_HEIGHT (f
);
4032 #endif /* !HAVE_X_WINDOWS */
4034 /* ----------------------- DOS / UNIX conversion --------------------- */
4036 void msdos_downcase_filename (unsigned char *);
4038 /* Destructively turn backslashes into slashes. */
4041 dostounix_filename (p
)
4044 msdos_downcase_filename (p
);
4054 /* Destructively turn slashes into backslashes. */
4057 unixtodos_filename (p
)
4060 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4074 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4077 getdefdir (drive
, dst
)
4081 char in_path
[4], *p
= in_path
;
4084 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4087 *p
++ = drive
+ 'A' - 1;
4094 _fixpath (in_path
, dst
);
4095 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4096 it queries the LFN support, so ignore that error. */
4097 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4100 msdos_downcase_filename (dst
);
4106 /* Remove all CR's that are followed by a LF. */
4111 register unsigned char *buf
;
4113 unsigned char *np
= buf
;
4114 unsigned char *startp
= buf
;
4115 unsigned char *endp
= buf
+ n
;
4119 while (buf
< endp
- 1)
4123 if (*(++buf
) != 0x0a)
4134 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4136 /* In DJGPP v2.0, library `write' can call `malloc', which might
4137 cause relocation of the buffer whose address we get in ADDR.
4138 Here is a version of `write' that avoids calling `malloc',
4139 to serve us until such time as the library is fixed.
4140 Actually, what we define here is called `__write', because
4141 `write' is a stub that just jmp's to `__write' (to be
4142 POSIXLY-correct with respect to the global name-space). */
4144 #include <io.h> /* for _write */
4145 #include <libc/dosio.h> /* for __file_handle_modes[] */
4147 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4149 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4152 __write (int handle
, const void *buffer
, size_t count
)
4157 if(__file_handle_modes
[handle
] & O_BINARY
)
4158 return _write (handle
, buffer
, count
);
4162 const char *bp
= buffer
;
4163 int total_written
= 0;
4164 int nmoved
= 0, ncr
= 0;
4168 /* The next test makes sure there's space for at least 2 more
4169 characters in xbuf[], so both CR and LF can be put there. */
4181 if (xbp
>= XBUF_END
|| !count
)
4183 size_t to_write
= nmoved
+ ncr
;
4184 int written
= _write (handle
, xbuf
, to_write
);
4189 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4191 /* If some, but not all were written (disk full?), return
4192 an estimate of the total written bytes not counting CRs. */
4193 if (written
< to_write
)
4194 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4201 return total_written
;
4205 /* A low-level file-renaming function which works around Windows 95 bug.
4206 This is pulled directly out of DJGPP v2.01 library sources, and only
4207 used when you compile with DJGPP v2.0. */
4211 int _rename(const char *old
, const char *new)
4214 int olen
= strlen(old
) + 1;
4216 int use_lfn
= _USE_LFN
;
4217 char tempfile
[FILENAME_MAX
];
4218 const char *orig
= old
;
4221 r
.x
.dx
= __tb_offset
;
4222 r
.x
.di
= __tb_offset
+ olen
;
4223 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4227 /* Windows 95 bug: for some filenames, when you rename
4228 file -> file~ (as in Emacs, to leave a backup), the
4229 short 8+3 alias doesn't change, which effectively
4230 makes OLD and NEW the same file. We must rename
4231 through a temporary file to work around this. */
4233 char *pbase
= 0, *p
;
4234 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4235 int idx
= sizeof(try_char
) - 1;
4237 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4238 might point to another drive, which will fail the DOS call. */
4239 strcpy(tempfile
, old
);
4240 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4241 if (*p
== '/' || *p
== '\\' || *p
== ':')
4247 strcpy(pbase
, "X$$djren$$.$$temp$$");
4253 *pbase
= try_char
[--idx
];
4254 } while (_chmod(tempfile
, 0) != -1);
4257 _put_path2(tempfile
, olen
);
4259 __dpmi_int(0x21, &r
);
4262 errno
= __doserr_to_errno(r
.x
.ax
);
4266 /* Now create a file with the original name. This will
4267 ensure that NEW will always have a 8+3 alias
4268 different from that of OLD. (Seems to be required
4269 when NameNumericTail in the Registry is set to 0.) */
4270 lfn_fd
= _creat(old
, 0);
4272 olen
= strlen(tempfile
) + 1;
4274 r
.x
.di
= __tb_offset
+ olen
;
4283 _put_path2(new, olen
);
4285 __dpmi_int(0x21, &r
);
4288 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4289 remove(new); /* and try again */
4292 errno
= __doserr_to_errno(r
.x
.ax
);
4294 /* Restore to original name if we renamed it to temporary. */
4302 _put_path2(orig
, olen
);
4303 _put_path(tempfile
);
4305 __dpmi_int(0x21, &r
);
4314 /* Success. Delete the file possibly created to work
4315 around the Windows 95 bug. */
4317 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4321 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4323 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4325 "Return non-nil if long file names are supported on MSDOS.")
4328 return (_USE_LFN
? Qt
: Qnil
);
4331 /* Convert alphabetic characters in a filename to lower-case. */
4334 msdos_downcase_filename (p
)
4335 register unsigned char *p
;
4337 /* Always lower-case drive letters a-z, even if the filesystem
4338 preserves case in filenames.
4339 This is so MSDOS filenames could be compared by string comparison
4340 functions that are case-sensitive. Even case-preserving filesystems
4341 do not distinguish case in drive letters. */
4342 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4348 /* Under LFN we expect to get pathnames in their true case. */
4349 if (NILP (Fmsdos_long_file_names ()))
4351 if (*p
>= 'A' && *p
<= 'Z')
4355 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4357 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4358 When long filenames are supported, doesn't change FILENAME.\n\
4359 If FILENAME is not a string, returns nil.\n\
4360 The argument object is never altered--the value is a copy.")
4362 Lisp_Object filename
;
4366 if (! STRINGP (filename
))
4369 tem
= Fcopy_sequence (filename
);
4370 msdos_downcase_filename (XSTRING (tem
)->data
);
4374 /* The Emacs root directory as determined by init_environment. */
4376 static char emacsroot
[MAXPATHLEN
];
4379 rootrelativepath (rel
)
4382 static char result
[MAXPATHLEN
+ 10];
4384 strcpy (result
, emacsroot
);
4385 strcat (result
, "/");
4386 strcat (result
, rel
);
4390 /* Define a lot of environment variables if not already defined. Don't
4391 remove anything unless you know what you're doing -- lots of code will
4392 break if one or more of these are missing. */
4395 init_environment (argc
, argv
, skip_args
)
4402 static const char * const tempdirs
[] = {
4403 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4406 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4408 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4409 temporary files and assume "/tmp" if $TMPDIR is unset, which
4410 will break on DOS/Windows. Refuse to work if we cannot find
4411 a directory, not even "c:/", usable for that purpose. */
4412 for (i
= 0; i
< imax
; i
++)
4414 const char *tmp
= tempdirs
[i
];
4417 tmp
= getenv (tmp
+ 1);
4418 /* Note that `access' can lie to us if the directory resides on a
4419 read-only filesystem, like CD-ROM or a write-protected floppy.
4420 The only way to be really sure is to actually create a file and
4421 see if it succeeds. But I think that's too much to ask. */
4422 if (tmp
&& access (tmp
, D_OK
) == 0)
4424 setenv ("TMPDIR", tmp
, 1);
4431 Fcons (build_string ("no usable temporary directories found!!"),
4433 "While setting TMPDIR: ");
4435 /* Note the startup time, so we know not to clear the screen if we
4436 exit immediately; see IT_reset_terminal_modes.
4437 (Yes, I know `clock' returns zero the first time it's called, but
4438 I do this anyway, in case some wiseguy changes that at some point.) */
4439 startup_time
= clock ();
4441 /* Find our root from argv[0]. Assuming argv[0] is, say,
4442 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4443 root
= alloca (MAXPATHLEN
+ 20);
4444 _fixpath (argv
[0], root
);
4445 msdos_downcase_filename (root
);
4446 len
= strlen (root
);
4447 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4451 && (strcmp (root
+ len
- 4, "/bin") == 0
4452 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4453 root
[len
- 4] = '\0';
4455 strcpy (root
, "c:/emacs"); /* let's be defensive */
4456 len
= strlen (root
);
4457 strcpy (emacsroot
, root
);
4459 /* We default HOME to our root. */
4460 setenv ("HOME", root
, 0);
4462 /* We default EMACSPATH to root + "/bin". */
4463 strcpy (root
+ len
, "/bin");
4464 setenv ("EMACSPATH", root
, 0);
4466 /* I don't expect anybody to ever use other terminals so the internal
4467 terminal is the default. */
4468 setenv ("TERM", "internal", 0);
4470 #ifdef HAVE_X_WINDOWS
4471 /* Emacs expects DISPLAY to be set. */
4472 setenv ("DISPLAY", "unix:0.0", 0);
4475 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4476 downcase it and mirror the backslashes. */
4477 s
= getenv ("COMSPEC");
4478 if (!s
) s
= "c:/command.com";
4479 t
= alloca (strlen (s
) + 1);
4481 dostounix_filename (t
);
4482 setenv ("SHELL", t
, 0);
4484 /* PATH is also downcased and backslashes mirrored. */
4485 s
= getenv ("PATH");
4487 t
= alloca (strlen (s
) + 3);
4488 /* Current directory is always considered part of MsDos's path but it is
4489 not normally mentioned. Now it is. */
4490 strcat (strcpy (t
, ".;"), s
);
4491 dostounix_filename (t
); /* Not a single file name, but this should work. */
4492 setenv ("PATH", t
, 1);
4494 /* In some sense all dos users have root privileges, so... */
4495 setenv ("USER", "root", 0);
4496 setenv ("NAME", getenv ("USER"), 0);
4498 /* Time zone determined from country code. To make this possible, the
4499 country code may not span more than one time zone. In other words,
4500 in the USA, you lose. */
4502 switch (dos_country_code
)
4504 case 31: /* Belgium */
4505 case 32: /* The Netherlands */
4506 case 33: /* France */
4507 case 34: /* Spain */
4508 case 36: /* Hungary */
4509 case 38: /* Yugoslavia (or what's left of it?) */
4510 case 39: /* Italy */
4511 case 41: /* Switzerland */
4512 case 42: /* Tjekia */
4513 case 45: /* Denmark */
4514 case 46: /* Sweden */
4515 case 47: /* Norway */
4516 case 48: /* Poland */
4517 case 49: /* Germany */
4518 /* Daylight saving from last Sunday in March to last Sunday in
4519 September, both at 2AM. */
4520 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4522 case 44: /* United Kingdom */
4523 case 351: /* Portugal */
4524 case 354: /* Iceland */
4525 setenv ("TZ", "GMT+00", 0);
4527 case 81: /* Japan */
4528 case 82: /* Korea */
4529 setenv ("TZ", "JST-09", 0);
4531 case 90: /* Turkey */
4532 case 358: /* Finland */
4533 setenv ("TZ", "EET-02", 0);
4535 case 972: /* Israel */
4536 /* This is an approximation. (For exact rules, use the
4537 `zoneinfo/israel' file which comes with DJGPP, but you need
4538 to install it in `/usr/share/zoneinfo/' directory first.) */
4539 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4547 static int break_stat
; /* BREAK check mode status. */
4548 static int stdin_stat
; /* stdin IOCTL status. */
4552 /* These must be global. */
4553 static _go32_dpmi_seginfo ctrl_break_vector
;
4554 static _go32_dpmi_registers ctrl_break_regs
;
4555 static int ctrlbreakinstalled
= 0;
4557 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4560 ctrl_break_func (regs
)
4561 _go32_dpmi_registers
*regs
;
4567 install_ctrl_break_check ()
4569 if (!ctrlbreakinstalled
)
4571 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4572 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4573 ctrlbreakinstalled
= 1;
4574 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4575 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4577 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4581 #endif /* __DJGPP__ < 2 */
4583 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4584 control chars by DOS. Determine the keyboard type. */
4589 union REGS inregs
, outregs
;
4590 static int first_time
= 1;
4592 break_stat
= getcbrk ();
4595 install_ctrl_break_check ();
4601 int86 (0x15, &inregs
, &outregs
);
4602 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4606 if (internal_terminal
4607 #ifdef HAVE_X_WINDOWS
4608 && inhibit_window_system
4612 inregs
.x
.ax
= 0x0021;
4613 int86 (0x33, &inregs
, &outregs
);
4614 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4617 /* Reportedly, the above doesn't work for some mouse drivers. There
4618 is an additional detection method that should work, but might be
4619 a little slower. Use that as an alternative. */
4620 inregs
.x
.ax
= 0x0000;
4621 int86 (0x33, &inregs
, &outregs
);
4622 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4627 have_mouse
= 1; /* enable mouse */
4629 mouse_setup_buttons (outregs
.x
.bx
);
4630 mouse_position_hook
= &mouse_get_pos
;
4634 #ifndef HAVE_X_WINDOWS
4636 /* Save the cursor shape used outside Emacs. */
4637 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4646 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4647 return (stdin_stat
!= -1);
4650 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4652 #else /* __DJGPP__ < 2 */
4656 /* I think it is wrong to overwrite `stdin_stat' every time
4657 but the first one this function is called, but I don't
4658 want to change the way it used to work in v1.x.--EZ */
4660 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4661 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4662 intdos (&inregs
, &outregs
);
4663 stdin_stat
= outregs
.h
.dl
;
4665 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4666 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4667 intdos (&inregs
, &outregs
);
4668 return !outregs
.x
.cflag
;
4670 #endif /* __DJGPP__ < 2 */
4673 /* Restore status of standard input and Ctrl-C checking. */
4678 union REGS inregs
, outregs
;
4680 setcbrk (break_stat
);
4685 #ifndef HAVE_X_WINDOWS
4686 /* Restore the cursor shape we found on startup. */
4690 inregs
.x
.cx
= outside_cursor
;
4691 int86 (0x10, &inregs
, &outregs
);
4695 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4697 #else /* not __DJGPP__ >= 2 */
4699 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4700 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4701 inregs
.x
.dx
= stdin_stat
;
4702 intdos (&inregs
, &outregs
);
4703 return !outregs
.x
.cflag
;
4705 #endif /* not __DJGPP__ >= 2 */
4709 /* Run command as specified by ARGV in directory DIR.
4710 The command is run with input from TEMPIN, output to
4711 file TEMPOUT and stderr to TEMPERR. */
4714 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4715 unsigned char **argv
;
4716 const char *working_dir
;
4717 int tempin
, tempout
, temperr
;
4720 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4721 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4722 int msshell
, result
= -1;
4723 int inbak
, outbak
, errbak
;
4727 /* Get current directory as MSDOS cwd is not per-process. */
4730 /* If argv[0] is the shell, it might come in any lettercase.
4731 Since `Fmember' is case-sensitive, we need to downcase
4732 argv[0], even if we are on case-preserving filesystems. */
4733 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4734 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4737 if (*pl
>= 'A' && *pl
<= 'Z')
4742 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4743 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4744 && !strcmp ("-c", argv
[1]);
4747 saveargv1
= argv
[1];
4748 saveargv2
= argv
[2];
4750 /* We only need to mirror slashes if a DOS shell will be invoked
4751 not via `system' (which does the mirroring itself). Yes, that
4752 means DJGPP v1.x will lose here. */
4753 if (argv
[2] && argv
[3])
4755 char *p
= alloca (strlen (argv
[2]) + 1);
4757 strcpy (argv
[2] = p
, saveargv2
);
4758 while (*p
&& isspace (*p
))
4770 chdir (working_dir
);
4774 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4775 goto done
; /* Allocation might fail due to lack of descriptors. */
4778 mouse_get_xy (&x
, &y
);
4780 dos_ttcooked (); /* do it here while 0 = stdin */
4788 if (msshell
&& !argv
[3])
4790 /* MS-DOS native shells are too restrictive. For starters, they
4791 cannot grok commands longer than 126 characters. In DJGPP v2
4792 and later, `system' is much smarter, so we'll call it instead. */
4796 /* A shell gets a single argument--its full command
4797 line--whose original was saved in `saveargv2'. */
4799 /* Don't let them pass empty command lines to `system', since
4800 with some shells it will try to invoke an interactive shell,
4801 which will hang Emacs. */
4802 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4806 extern char **environ
;
4807 char **save_env
= environ
;
4808 int save_system_flags
= __system_flags
;
4810 /* Request the most powerful version of `system'. We need
4811 all the help we can get to avoid calling stock DOS shells. */
4812 __system_flags
= (__system_redirect
4813 | __system_use_shell
4814 | __system_allow_multiple_cmds
4815 | __system_allow_long_cmds
4816 | __system_handle_null_commands
4817 | __system_emulate_chdir
);
4820 result
= system (cmnd
);
4821 __system_flags
= save_system_flags
;
4825 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4829 #endif /* __DJGPP__ > 1 */
4831 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4836 emacs_close (inbak
);
4837 emacs_close (outbak
);
4838 emacs_close (errbak
);
4844 mouse_moveto (x
, y
);
4847 /* Some programs might change the meaning of the highest bit of the
4848 text attribute byte, so we get blinking characters instead of the
4849 bright background colors. Restore that. */
4856 argv
[1] = saveargv1
;
4857 argv
[2] = saveargv2
;
4865 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4872 /* ------------------------- Compatibility functions -------------------
4877 /* Hostnames for a pc are not really funny,
4878 but they are used in change log so we emulate the best we can. */
4880 gethostname (p
, size
)
4884 char *q
= egetenv ("HOSTNAME");
4891 /* When time zones are set from Ms-Dos too many C-libraries are playing
4892 tricks with time values. We solve this by defining our own version
4893 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4894 once and after each call to `tzset' with TZ changed. That is
4895 accomplished by aliasing tzset to init_gettimeofday. */
4897 static struct tm time_rec
;
4900 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4908 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4912 time_rec
.tm_year
= d
.da_year
- 1900;
4913 time_rec
.tm_mon
= d
.da_mon
- 1;
4914 time_rec
.tm_mday
= d
.da_day
;
4917 time_rec
.tm_hour
= t
.ti_hour
;
4918 time_rec
.tm_min
= t
.ti_min
;
4919 time_rec
.tm_sec
= t
.ti_sec
;
4922 tm
.tm_gmtoff
= dos_timezone_offset
;
4924 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4925 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4927 /* Ignore tzp; it's obsolescent. */
4931 #endif /* __DJGPP__ < 2 */
4934 * A list of unimplemented functions that we silently ignore.
4938 unsigned alarm (s
) unsigned s
; {}
4939 fork () { return 0; }
4940 int kill (x
, y
) int x
, y
; { return -1; }
4942 void volatile pause () {}
4943 sigsetmask (x
) int x
; { return 0; }
4944 sigblock (mask
) int mask
; { return 0; }
4947 void request_sigio (void) {}
4948 setpgrp () {return 0; }
4949 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4950 void unrequest_sigio (void) {}
4954 #ifdef POSIX_SIGNALS
4956 /* Augment DJGPP library POSIX signal functions. This is needed
4957 as of DJGPP v2.01, but might be in the library in later releases. */
4959 #include <libc/bss.h>
4961 /* A counter to know when to re-initialize the static sets. */
4962 static int sigprocmask_count
= -1;
4964 /* Which signals are currently blocked (initially none). */
4965 static sigset_t current_mask
;
4967 /* Which signals are pending (initially none). */
4968 static sigset_t pending_signals
;
4970 /* Previous handlers to restore when the blocked signals are unblocked. */
4971 typedef void (*sighandler_t
)(int);
4972 static sighandler_t prev_handlers
[320];
4974 /* A signal handler which just records that a signal occured
4975 (it will be raised later, if and when the signal is unblocked). */
4977 sig_suspender (signo
)
4980 sigaddset (&pending_signals
, signo
);
4984 sigprocmask (how
, new_set
, old_set
)
4986 const sigset_t
*new_set
;
4992 /* If called for the first time, initialize. */
4993 if (sigprocmask_count
!= __bss_count
)
4995 sigprocmask_count
= __bss_count
;
4996 sigemptyset (&pending_signals
);
4997 sigemptyset (¤t_mask
);
4998 for (signo
= 0; signo
< 320; signo
++)
4999 prev_handlers
[signo
] = SIG_ERR
;
5003 *old_set
= current_mask
;
5008 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
5014 sigemptyset (&new_mask
);
5016 /* DJGPP supports upto 320 signals. */
5017 for (signo
= 0; signo
< 320; signo
++)
5019 if (sigismember (¤t_mask
, signo
))
5020 sigaddset (&new_mask
, signo
);
5021 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
5023 sigaddset (&new_mask
, signo
);
5025 /* SIGKILL is silently ignored, as on other platforms. */
5026 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
5027 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
5029 if (( how
== SIG_UNBLOCK
5030 && sigismember (&new_mask
, signo
)
5031 && sigismember (new_set
, signo
))
5032 || (how
== SIG_SETMASK
5033 && sigismember (&new_mask
, signo
)
5034 && !sigismember (new_set
, signo
)))
5036 sigdelset (&new_mask
, signo
);
5037 if (prev_handlers
[signo
] != SIG_ERR
)
5039 signal (signo
, prev_handlers
[signo
]);
5040 prev_handlers
[signo
] = SIG_ERR
;
5042 if (sigismember (&pending_signals
, signo
))
5044 sigdelset (&pending_signals
, signo
);
5049 current_mask
= new_mask
;
5053 #else /* not POSIX_SIGNALS */
5055 sigsetmask (x
) int x
; { return 0; }
5056 sigblock (mask
) int mask
; { return 0; }
5058 #endif /* not POSIX_SIGNALS */
5059 #endif /* __DJGPP__ > 1 */
5062 #include "sysselect.h"
5064 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5065 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5066 ((long)(time).tv_sec < 0 \
5067 || ((time).tv_sec == 0 \
5068 && (long)(time).tv_usec <= 0))
5071 /* This yields the rest of the current time slice to the task manager.
5072 It should be called by any code which knows that it has nothing
5073 useful to do except idle.
5075 I don't use __dpmi_yield here, since versions of library before 2.02
5076 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5077 on some versions of Windows 9X. */
5080 dos_yield_time_slice (void)
5082 _go32_dpmi_registers r
;
5085 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5086 _go32_dpmi_simulate_int (0x2f, &r
);
5091 /* Only event queue is checked. */
5092 /* We don't have to call timer_check here
5093 because wait_reading_process_input takes care of that. */
5095 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5097 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5098 EMACS_TIME
*timeout
;
5106 check_input
= FD_ISSET (0, rfds
);
5117 /* If we are looking only for the terminal, with no timeout,
5118 just read it and wait -- that's more efficient. */
5121 while (!detect_input_pending ())
5123 dos_yield_time_slice ();
5128 EMACS_TIME clnow
, cllast
, cldiff
;
5131 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5133 while (!check_input
|| !detect_input_pending ())
5136 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5137 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5139 /* When seconds wrap around, we assume that no more than
5140 1 minute passed since last `gettime'. */
5141 if (EMACS_TIME_NEG_P (cldiff
))
5142 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5143 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5145 /* Stop when timeout value crosses zero. */
5146 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5149 dos_yield_time_slice ();
5159 * Define overlaid functions:
5161 * chdir -> sys_chdir
5162 * tzset -> init_gettimeofday
5163 * abort -> dos_abort
5168 extern int chdir ();
5174 int len
= strlen (path
);
5175 char *tmp
= (char *)path
;
5177 if (*tmp
&& tmp
[1] == ':')
5179 if (getdisk () != tolower (tmp
[0]) - 'a')
5180 setdisk (tolower (tmp
[0]) - 'a');
5181 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5185 if (len
> 1 && (tmp
[len
- 1] == '/'))
5187 char *tmp1
= (char *) alloca (len
+ 1);
5198 extern void tzset (void);
5201 init_gettimeofday ()
5207 ltm
= gtm
= time (NULL
);
5208 ltm
= mktime (lstm
= localtime (<m
));
5209 gtm
= mktime (gmtime (>m
));
5210 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5211 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5212 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5219 dos_abort (file
, line
)
5223 char buffer1
[200], buffer2
[400];
5226 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5227 for (i
= j
= 0; buffer1
[i
]; i
++) {
5228 buffer2
[j
++] = buffer1
[i
];
5229 buffer2
[j
++] = 0x70;
5231 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5232 ScreenSetCursor (2, 0);
5240 ScreenSetCursor (10, 0);
5241 cputs ("\r\n\nEmacs aborted!\r\n");
5243 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5244 if (screen_virtual_segment
)
5245 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5246 /* Generate traceback, so we could tell whodunit. */
5247 signal (SIGINT
, SIG_DFL
);
5248 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5249 #else /* __DJGPP_MINOR__ >= 2 */
5251 #endif /* __DJGPP_MINOR__ >= 2 */
5257 /* The following variables are required so that cus-start.el won't
5258 complain about unbound variables. */
5259 #ifndef HAVE_X_WINDOWS
5260 /* Search path for bitmap files (xfns.c). */
5261 Lisp_Object Vx_bitmap_file_path
;
5262 int x_stretch_cursor_p
;
5264 #ifndef subprocesses
5265 /* Nonzero means delete a process right away if it exits (process.c). */
5266 static int delete_exited_processes
;
5271 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5272 staticpro (&recent_doskeys
);
5273 #ifndef HAVE_X_WINDOWS
5275 staticpro (&help_echo
);
5276 help_echo_object
= Qnil
;
5277 staticpro (&help_echo_object
);
5278 help_echo_window
= Qnil
;
5279 staticpro (&help_echo_window
);
5280 previous_help_echo
= Qnil
;
5281 staticpro (&previous_help_echo
);
5284 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5285 "List of directories to search for bitmap files for X.");
5286 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5288 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5289 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5290 For example, if a block cursor is over a tab, it will be drawn as\n\
5291 wide as that tab on the display. (No effect on MS-DOS.)");
5292 x_stretch_cursor_p
= 0;
5294 /* The following two are from xfns.c: */
5295 Qbar
= intern ("bar");
5297 Qcursor_type
= intern ("cursor-type");
5298 staticpro (&Qcursor_type
);
5299 Qreverse
= intern ("reverse");
5300 staticpro (&Qreverse
);
5302 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5303 "*Glyph to display instead of chars not supported by current codepage.\n\
5305 This variable is used only by MSDOS terminals.");
5306 Vdos_unsupported_char_glyph
= '\177';
5308 #ifndef subprocesses
5309 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5310 "*Non-nil means delete processes immediately when they exit.\n\
5311 nil means don't delete them until `list-processes' is run.");
5312 delete_exited_processes
= 0;
5315 defsubr (&Srecent_doskeys
);
5316 defsubr (&Smsdos_long_file_names
);
5317 defsubr (&Smsdos_downcase_filename
);
5318 defsubr (&Smsdos_remember_default_colors
);
5319 defsubr (&Smsdos_set_mouse_buttons
);