1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Morten Welinder */
22 /* New display, keyboard, and mouse control by Kim F. Storm */
24 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
33 #include <sys/param.h>
37 #include <string.h> /* for bzero and string functions */
38 #include <sys/stat.h> /* for _fixpath */
39 #include <unistd.h> /* for chdir, dup, dup2, etc. */
42 #include <io.h> /* for setmode */
43 #include <dpmi.h> /* for __dpmi_xxx stuff */
44 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
45 #include <libc/dosio.h> /* for _USE_LFN */
46 #include <conio.h> /* for cputs */
51 #include "termhooks.h"
53 #include "dispextern.h"
63 #include "blockinput.h"
67 /* #include <process.h> */
68 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
76 #define _dos_ds _go32_info_block.selector_for_linear_memory
82 #include "syssignal.h"
88 /* If other `malloc' than ours is used, force our `sbrk' behave like
89 Unix programs expect (resize memory blocks to keep them contiguous).
90 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
91 because that's what `gmalloc' expects to get. */
95 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
96 #else /* not REL_ALLOC */
97 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
98 #endif /* not REL_ALLOC */
99 #endif /* GNU_MALLOC */
101 #endif /* not SYSTEM_MALLOC */
102 #endif /* __DJGPP__ > 1 */
121 /* ------------------------ Mouse control ---------------------------
123 * Coordinates are in screen positions and zero based.
124 * Mouse buttons are numbered from left to right and also zero based.
127 /* This used to be in termhooks.h, but mainstream Emacs code no longer
128 uses it, and it was removed... */
129 #define NUM_MOUSE_BUTTONS (5)
131 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
132 static int mouse_visible
;
134 static int mouse_last_x
;
135 static int mouse_last_y
;
137 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
138 static int mouse_button_count
;
145 if (have_mouse
> 0 && !mouse_visible
)
148 fprintf (termscript
, "<M_ON>");
150 int86 (0x33, ®s
, ®s
);
160 if (have_mouse
> 0 && mouse_visible
)
163 fprintf (termscript
, "<M_OFF>");
165 int86 (0x33, ®s
, ®s
);
171 mouse_get_xy (int *x
, int *y
)
176 int86 (0x33, ®s
, ®s
);
188 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
190 mouse_last_x
= regs
.x
.cx
= x
* 8;
191 mouse_last_y
= regs
.x
.dx
= y
* 8;
192 int86 (0x33, ®s
, ®s
);
196 mouse_pressed (b
, xp
, yp
)
201 if (b
>= mouse_button_count
)
204 regs
.x
.bx
= mouse_button_translate
[b
];
205 int86 (0x33, ®s
, ®s
);
207 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
208 return (regs
.x
.bx
!= 0);
212 mouse_released (b
, xp
, yp
)
217 if (b
>= mouse_button_count
)
220 regs
.x
.bx
= mouse_button_translate
[b
];
221 int86 (0x33, ®s
, ®s
);
223 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
224 return (regs
.x
.bx
!= 0);
228 mouse_button_depressed (b
, xp
, yp
)
233 if (b
>= mouse_button_count
)
236 int86 (0x33, ®s
, ®s
);
237 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
247 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
250 Lisp_Object
*bar_window
, *x
, *y
;
251 enum scroll_bar_part
*part
;
255 Lisp_Object frame
, tail
;
257 /* Clear the mouse-moved flag for every frame on this display. */
258 FOR_EACH_FRAME (tail
, frame
)
259 XFRAME (frame
)->mouse_moved
= 0;
261 *f
= SELECTED_FRAME();
263 mouse_get_xy (&ix
, &iy
);
264 *time
= event_timestamp ();
265 *x
= make_number (mouse_last_x
= ix
);
266 *y
= make_number (mouse_last_y
= iy
);
274 mouse_get_xy (&x
, &y
);
275 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
287 fprintf (termscript
, "<M_INIT>");
290 int86 (0x33, ®s
, ®s
);
292 /* Reset the mouse last press/release info. It seems that Windows
293 doesn't do that automatically when function 21h is called, which
294 causes Emacs to ``remember'' the click that switched focus to the
295 window just before Emacs was started from that window. */
296 for (b
= 0; b
< mouse_button_count
; b
++)
298 int dummy_x
, dummy_y
;
300 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
301 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
306 regs
.x
.dx
= 8 * (ScreenCols () - 1);
307 int86 (0x33, ®s
, ®s
);
311 regs
.x
.dx
= 8 * (ScreenRows () - 1);
312 int86 (0x33, ®s
, ®s
);
318 /* ------------------------- Screen control ----------------------
322 static int internal_terminal
= 0;
324 #ifndef HAVE_X_WINDOWS
325 extern unsigned char ScreenAttrib
;
326 static int screen_face
;
327 static int highlight
;
329 static int screen_size_X
;
330 static int screen_size_Y
;
331 static int screen_size
;
333 static int current_pos_X
;
334 static int current_pos_Y
;
335 static int new_pos_X
;
336 static int new_pos_Y
;
338 static void *startup_screen_buffer
;
339 static int startup_screen_size_X
;
340 static int startup_screen_size_Y
;
341 static int startup_pos_X
;
342 static int startup_pos_Y
;
343 static unsigned char startup_screen_attrib
;
345 static clock_t startup_time
;
347 static int term_setup_done
;
349 static unsigned short outside_cursor
;
351 /* Similar to the_only_frame. */
352 struct x_output the_only_x_display
;
354 /* Support for DOS/V (allows Japanese characters to be displayed on
355 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
357 /* Holds the address of the text-mode screen buffer. */
358 static unsigned long screen_old_address
= 0;
359 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
360 static unsigned short screen_virtual_segment
= 0;
361 static unsigned short screen_virtual_offset
= 0;
362 /* A flag to control how to display unibyte 8-bit characters. */
363 extern int unibyte_display_via_language_environment
;
368 /* Update the screen from a part of relocated DOS/V screen buffer which
369 begins at OFFSET and includes COUNT characters. */
371 dosv_refresh_virtual_screen (int offset
, int count
)
375 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
378 regs
.h
.ah
= 0xff; /* update relocated screen */
379 regs
.x
.es
= screen_virtual_segment
;
380 regs
.x
.di
= screen_virtual_offset
+ offset
;
382 __dpmi_int (0x10, ®s
);
387 dos_direct_output (y
, x
, buf
, len
)
393 int t0
= 2 * (x
+ y
* screen_size_X
);
394 int t
= t0
+ (int) ScreenPrimary
;
399 dosmemput (buf
++, 1, t
);
403 /* This is faster. */
404 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
405 _farnspokeb (t
, *buf
);
407 if (screen_virtual_segment
)
408 dosv_refresh_virtual_screen (t0
, l0
);
413 /* Flash the screen as a substitute for BEEPs. */
417 do_visible_bell (xorattr
)
418 unsigned char xorattr
;
423 movl _ScreenPrimary,%%eax
430 xorb %%al,%%gs:(%%ebx)
446 : "m" (xorattr
), "g" (screen_size
)
447 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
451 ScreenVisualBell (void)
453 /* This creates an xor-mask that will swap the default fore- and
454 background colors. */
455 do_visible_bell (((the_only_x_display
.foreground_pixel
456 ^ the_only_x_display
.background_pixel
)
461 #ifndef HAVE_X_WINDOWS
463 static int blink_bit
= -1; /* the state of the blink bit at startup */
465 /* Enable bright background colors. */
471 /* Remember the original state of the blink/bright-background bit.
472 It is stored at 0040:0065h in the BIOS data area. */
474 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
478 int86 (0x10, ®s
, ®s
);
481 /* Disable bright background colors (and enable blinking) if we found
482 the video system in that state at startup. */
484 maybe_enable_blinking (void)
492 int86 (0x10, ®s
, ®s
);
496 /* Return non-zero if the system has a VGA adapter. */
503 int86 (0x10, ®s
, ®s
);
504 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
509 /* Set the screen dimensions so that it can show no less than
510 ROWS x COLS frame. */
513 dos_set_window_size (rows
, cols
)
517 Lisp_Object video_mode
;
518 int video_mode_value
;
521 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
523 if (*rows
== current_rows
&& *cols
== current_cols
)
527 have_vga
= vga_installed ();
529 /* If the user specified a special video mode for these dimensions,
531 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
532 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
535 if (INTEGERP (video_mode
)
536 && (video_mode_value
= XINT (video_mode
)) > 0)
538 regs
.x
.ax
= video_mode_value
;
539 int86 (0x10, ®s
, ®s
);
543 /* Must hardware-reset the mouse, or else it won't update
544 its notion of screen dimensions for some non-standard
545 video modes. This is *painfully* slow... */
547 int86 (0x33, ®s
, ®s
);
551 /* Find one of the dimensions supported by standard EGA/VGA
552 which gives us at least the required dimensions. */
561 } std_dimension
[] = {
571 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
573 if (std_dimension
[i
].need_vga
<= have_vga
574 && std_dimension
[i
].rows
>= *rows
)
576 if (std_dimension
[i
].rows
!= current_rows
577 || *cols
!= current_cols
)
578 _set_screen_lines (std_dimension
[i
].rows
);
585 #else /* not __DJGPP__ > 1 */
587 else if (*rows
<= 25)
589 if (current_rows
!= 25 || current_cols
!= 80)
592 int86 (0x10, ®s
, ®s
);
595 int86 (0x10, ®s
, ®s
);
598 int86 (0x10, ®s
, ®s
);
600 int86 (0x10, ®s
, ®s
);
603 else if (*rows
<= 50)
604 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
605 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
608 int86 (0x10, ®s
, ®s
);
611 int86 (0x10, ®s
, ®s
);
614 int86 (0x10, ®s
, ®s
);
617 int86 (0x10, ®s
, ®s
);
619 #endif /* not __DJGPP__ > 1 */
627 /* Tell the caller what dimensions have been REALLY set. */
628 *rows
= ScreenRows ();
629 *cols
= ScreenCols ();
632 /* If the dimensions changed, the mouse highlight info is invalid. */
633 if (current_rows
!= *rows
|| current_cols
!= *cols
)
635 struct frame
*f
= SELECTED_FRAME();
636 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
637 Lisp_Object window
= dpyinfo
->mouse_face_window
;
639 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
641 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
642 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
643 dpyinfo
->mouse_face_window
= Qnil
;
648 /* Enable bright background colors. */
651 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
652 be defensive anyway. */
653 if (screen_virtual_segment
)
654 dosv_refresh_virtual_screen (0, *cols
* *rows
);
657 /* If we write a character in the position where the mouse is,
658 the mouse cursor may need to be refreshed. */
668 mouse_get_xy (&x
, &y
);
669 if (y
!= new_pos_Y
|| x
< new_pos_X
)
675 #define DEFAULT_CURSOR_START (-1)
676 #define DEFAULT_CURSOR_WIDTH (-1)
677 #define BOX_CURSOR_WIDTH (-32)
679 /* Set cursor to begin at scan line START_LINE in the character cell
680 and extend for WIDTH scan lines. Scan lines are counted from top
681 of the character cell, starting from zero. */
683 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
686 unsigned desired_cursor
;
688 int max_line
, top_line
, bot_line
;
690 /* Avoid the costly BIOS call if F isn't the currently selected
691 frame. Allow for NULL as unconditionally meaning the selected
693 if (f
&& f
!= SELECTED_FRAME())
696 /* The character cell size in scan lines is stored at 40:85 in the
698 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
701 default: /* this relies on CGA cursor emulation being ON! */
718 if (width
== BOX_CURSOR_WIDTH
)
723 else if (start_line
!= DEFAULT_CURSOR_START
)
725 top_line
= start_line
;
726 bot_line
= top_line
- width
- 1;
728 else if (width
!= DEFAULT_CURSOR_WIDTH
)
731 bot_line
= -1 - width
;
734 top_line
= bot_line
+ 1;
738 /* [31, 0] seems to DTRT for all screen sizes. */
742 else /* WIDTH is positive */
744 if (start_line
!= DEFAULT_CURSOR_START
)
745 bot_line
= start_line
;
746 top_line
= bot_line
- (width
- 1);
749 /* If the current cursor shape is already what they want, we are
751 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
752 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
756 regs
.x
.cx
= desired_cursor
;
757 __dpmi_int (0x10, ®s
);
758 #endif /* __DJGPP__ > 1 */
762 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
764 if (EQ (cursor_type
, Qbar
))
766 /* Just BAR means the normal EGA/VGA cursor. */
767 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
769 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
771 Lisp_Object bar_parms
= XCDR (cursor_type
);
774 if (INTEGERP (bar_parms
))
776 /* Feature: negative WIDTH means cursor at the top
777 of the character cell, zero means invisible cursor. */
778 width
= XINT (bar_parms
);
779 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
782 else if (CONSP (bar_parms
)
783 && INTEGERP (XCAR (bar_parms
))
784 && INTEGERP (XCDR (bar_parms
)))
786 int start_line
= XINT (XCDR (bar_parms
));
788 width
= XINT (XCAR (bar_parms
));
789 msdos_set_cursor_shape (f
, start_line
, width
);
793 /* Treat anything unknown as "box cursor". This includes nil, so
794 that a frame which doesn't specify a cursor type gets a box,
795 which is the default in Emacs. */
796 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
809 union REGS inregs
, outregs
;
812 intdos (&inregs
, &outregs
);
816 /* Given a face id FACE, extract the face parameters to be used for
817 display until the face changes. The face parameters (actually, its
818 color) are used to construct the video attribute byte for each
819 glyph during the construction of the buffer that is then blitted to
822 IT_set_face (int face
)
824 struct frame
*sf
= SELECTED_FRAME();
825 struct face
*fp
= FACE_FROM_ID (sf
, face
);
826 unsigned long fg
, bg
;
830 fp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
831 /* The default face for the frame should always be realized and
840 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
841 colors mean use the colors of the default face, except that if
842 highlight is on, invert the foreground and the background. Note
843 that we assume all 16 colors to be available for the background,
844 since Emacs switches on this mode (and loses the blinking
845 attribute) at startup. */
846 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
847 fg
= FRAME_FOREGROUND_PIXEL (sf
);
848 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
849 fg
= FRAME_BACKGROUND_PIXEL (sf
);
850 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
851 bg
= FRAME_BACKGROUND_PIXEL (sf
);
852 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
853 bg
= FRAME_FOREGROUND_PIXEL (sf
);
855 /* Make sure highlighted lines really stand out, come what may. */
856 if ((highlight
|| fp
->tty_reverse_p
)
857 && (fg
== FRAME_FOREGROUND_PIXEL (sf
)
858 && bg
== FRAME_BACKGROUND_PIXEL (sf
)))
860 unsigned long tem
= fg
;
866 fprintf (termscript
, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face
,
867 highlight
? "H" : "", fp
->foreground
, fp
->background
, fg
, bg
);
868 if (fg
>= 0 && fg
< 16)
870 ScreenAttrib
&= 0xf0;
873 if (bg
>= 0 && bg
< 16)
875 ScreenAttrib
&= 0x0f;
876 ScreenAttrib
|= ((bg
& 0x0f) << 4);
880 Lisp_Object Vdos_unsupported_char_glyph
;
883 IT_write_glyphs (struct glyph
*str
, int str_len
)
885 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
886 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
887 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
888 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
889 register int sl
= str_len
;
890 register int tlen
= GLYPH_TABLE_LENGTH
;
891 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
893 struct coding_system
*coding
= (CODING_REQUIRE_ENCODING (&terminal_coding
)
895 : &safe_terminal_coding
);
898 /* Do we need to consider conversion of unibyte characters to
900 int convert_unibyte_characters
901 = (NILP (current_buffer
->enable_multibyte_characters
)
902 && unibyte_display_via_language_environment
);
904 if (str_len
<= 0) return;
906 screen_buf
= screen_bp
= alloca (str_len
* 2);
907 screen_buf_end
= screen_buf
+ str_len
* 2;
908 sf
= SELECTED_FRAME();
910 /* Since faces get cached and uncached behind our back, we can't
911 rely on their indices in the cache being consistent across
912 invocations. So always reset the screen face to the default
913 face of the frame, before writing glyphs, and let the glyphs
914 set the right face if it's different from the default. */
915 IT_set_face (DEFAULT_FACE_ID
);
917 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
919 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
922 int cf
, chlen
, enclen
;
923 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
926 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
927 only for the redisplay code to know how many columns does
928 this character occupy on the screen. Skip padding glyphs. */
929 if (CHAR_GLYPH_PADDING_P (*str
))
936 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
937 int glyph_not_in_table
= 0;
939 if (g
< 0 || g
>= tlen
)
941 /* This glyph doesn't have an entry in Vglyph_table. */
943 glyph_not_in_table
= 1;
947 /* This glyph has an entry in Vglyph_table, so process
948 any aliases before testing for simpleness. */
949 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
950 ch
= FAST_GLYPH_CHAR (g
);
953 /* Convert the character code to multibyte, if they
954 requested display via language environment. We only want
955 to convert unibyte characters to multibyte in unibyte
956 buffers! Otherwise, the 8-bit value in CH came from the
957 display table set up to display foreign characters. */
958 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
960 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
961 ch
= unibyte_char_to_multibyte (ch
);
963 /* Invalid characters are displayed with a special glyph. */
964 if (! CHAR_VALID_P (ch
, 0))
966 g
= !NILP (Vdos_unsupported_char_glyph
)
967 ? Vdos_unsupported_char_glyph
968 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
969 ch
= FAST_GLYPH_CHAR (g
);
972 /* If the face of this glyph is different from the current
973 screen face, update the screen attribute byte. */
974 cf
= FAST_GLYPH_FACE (g
);
975 if (cf
!= screen_face
)
976 IT_set_face (cf
); /* handles invalid faces gracefully */
978 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
980 /* We generate the multi-byte form of CH in WORKBUF. */
981 chlen
= CHAR_STRING (ch
, workbuf
);
986 /* We have a string in Vglyph_table. */
987 chlen
= GLYPH_LENGTH (tbase
, g
);
988 buf
= GLYPH_STRING (tbase
, g
);
991 /* If the character is not multibyte, don't bother converting it. */
994 *conversion_buffer
= (unsigned char)ch
;
1000 coding
->src_multibyte
= 1;
1001 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1002 conversion_buffer_size
);
1003 chlen
-= coding
->consumed
;
1004 enclen
= coding
->produced
;
1006 /* Replace glyph codes that cannot be converted by
1007 terminal_coding with Vdos_unsupported_char_glyph. */
1008 if (*conversion_buffer
== '?')
1010 char *cbp
= conversion_buffer
;
1012 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1013 *cbp
++ = unsupported_char
;
1014 if (unsupported_face
!= screen_face
)
1015 IT_set_face (unsupported_face
);
1019 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1021 /* The allocated buffer for screen writes is too small.
1022 Flush it and loop again without incrementing STR, so
1023 that the next loop will begin with the same glyph. */
1024 int nbytes
= screen_bp
- screen_buf
;
1027 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1028 if (screen_virtual_segment
)
1029 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1030 new_pos_X
+= nbytes
/ 2;
1033 /* Prepare to reuse the same buffer again. */
1034 screen_bp
= screen_buf
;
1038 /* There's enough place in the allocated buffer to add
1039 the encoding of this glyph. */
1041 /* First, copy the encoded bytes. */
1042 for (bp
= conversion_buffer
; enclen
--; bp
++)
1044 *screen_bp
++ = (unsigned char)*bp
;
1045 *screen_bp
++ = ScreenAttrib
;
1047 fputc (*bp
, termscript
);
1050 /* Now copy the bytes not consumed by the encoding. */
1053 buf
+= coding
->consumed
;
1057 fputc (*buf
, termscript
);
1058 *screen_bp
++ = (unsigned char)*buf
++;
1059 *screen_bp
++ = ScreenAttrib
;
1063 /* Update STR and its remaining length. */
1070 /* Dump whatever is left in the screen buffer. */
1072 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1073 if (screen_virtual_segment
)
1074 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1075 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1077 /* We may have to output some codes to terminate the writing. */
1078 if (CODING_REQUIRE_FLUSHING (coding
))
1080 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1081 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1082 if (coding
->produced
> 0)
1084 screen_buf
= alloca (coding
->produced
* 2);
1085 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1086 coding
->produced
--; bp
++)
1088 *screen_bp
++ = (unsigned char)*bp
;
1089 *screen_bp
++ = ScreenAttrib
;
1091 fputc (*bp
, termscript
);
1093 offset
+= screen_bp
- screen_buf
;
1095 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1096 (int)ScreenPrimary
+ offset
);
1097 if (screen_virtual_segment
)
1098 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1099 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1104 /************************************************************************
1105 Mouse Highlight (and friends..)
1106 ************************************************************************/
1108 /* This is used for debugging, to turn off note_mouse_highlight. */
1109 int disable_mouse_highlight
;
1111 /* If a string, dos_rawgetc generates an event to display that string.
1112 (The display is done in keyboard.c:read_char.) */
1113 static Lisp_Object help_echo
;
1114 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1116 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1118 /* Set the mouse pointer shape according to whether it is in the
1119 area where the mouse highlight is in effect. */
1121 IT_set_mouse_pointer (int mode
)
1123 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1124 many possibilities to change its shape, and the available
1125 functionality pretty much sucks (e.g., almost every reasonable
1126 shape will conceal the character it is on). Since the color of
1127 the pointer changes in the highlighted area, it is not clear to
1128 me whether anything else is required, anyway. */
1131 /* Display the active region described by mouse_face_*
1132 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1134 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1136 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1137 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1142 /* If window is in the process of being destroyed, don't bother
1144 if (w
->current_matrix
== NULL
)
1145 goto set_cursor_shape
;
1147 /* Recognize when we are called to operate on rows that don't exist
1148 anymore. This can happen when a window is split. */
1149 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1150 goto set_cursor_shape
;
1152 /* There's no sense to do anything if the mouse face isn't realized. */
1155 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1157 goto set_cursor_shape
;
1160 /* Note that mouse_face_beg_row etc. are window relative. */
1161 for (i
= dpyinfo
->mouse_face_beg_row
;
1162 i
<= dpyinfo
->mouse_face_end_row
;
1165 int start_hpos
, end_hpos
;
1166 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1168 /* Don't do anything if row doesn't have valid contents. */
1169 if (!row
->enabled_p
)
1172 /* For all but the first row, the highlight starts at column 0. */
1173 if (i
== dpyinfo
->mouse_face_beg_row
)
1174 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1178 if (i
== dpyinfo
->mouse_face_end_row
)
1179 end_hpos
= dpyinfo
->mouse_face_end_col
;
1181 end_hpos
= row
->used
[TEXT_AREA
];
1183 if (end_hpos
<= start_hpos
)
1187 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1188 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1189 int nglyphs
= end_hpos
- start_hpos
;
1190 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1191 int start_offset
= offset
;
1194 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1195 kstart
, kstart
+ nglyphs
- 1, vpos
);
1198 IT_set_face (dpyinfo
->mouse_face_face_id
);
1199 /* Since we are going to change only the _colors_ of the
1200 displayed text, there's no need to go through all the
1201 pain of generating and encoding the text from the glyphs.
1202 Instead, we simply poke the attribute byte of each
1203 affected position in video memory with the colors
1204 computed by IT_set_face! */
1205 _farsetsel (_dos_ds
);
1208 _farnspokeb (offset
, ScreenAttrib
);
1211 if (screen_virtual_segment
)
1212 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1217 /* We are removing a previously-drawn mouse highlight. The
1218 safest way to do so is to redraw the glyphs anew, since
1219 all kinds of faces and display tables could have changed
1221 int nglyphs
= end_hpos
- start_hpos
;
1222 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1224 if (end_hpos
>= row
->used
[TEXT_AREA
])
1225 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1227 /* IT_write_glyphs writes at cursor position, so we need to
1228 temporarily move cursor coordinates to the beginning of
1229 the highlight region. */
1230 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1231 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1234 fprintf (termscript
, "<MH- %d-%d:%d>",
1235 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1236 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1238 fputs ("\n", termscript
);
1246 /* Change the mouse pointer shape. */
1247 IT_set_mouse_pointer (hl
);
1250 /* Clear out the mouse-highlighted active region.
1251 Redraw it un-highlighted first. */
1253 clear_mouse_face (struct display_info
*dpyinfo
)
1255 if (! NILP (dpyinfo
->mouse_face_window
))
1256 show_mouse_face (dpyinfo
, 0);
1258 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1259 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1260 dpyinfo
->mouse_face_window
= Qnil
;
1263 /* Find the glyph matrix position of buffer position POS in window W.
1264 *HPOS and *VPOS are set to the positions found. W's current glyphs
1265 must be up to date. If POS is above window start return (0, 0).
1266 If POS is after end of W, return end of last line in W. */
1268 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1272 int maybe_next_line_p
= 0;
1273 int line_start_position
;
1274 int yb
= window_text_bottom_y (w
);
1275 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1276 struct glyph_row
*best_row
= row
;
1280 if (row
->used
[TEXT_AREA
])
1281 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1283 line_start_position
= 0;
1285 if (line_start_position
> pos
)
1287 /* If the position sought is the end of the buffer,
1288 don't include the blank lines at the bottom of the window. */
1289 else if (line_start_position
== pos
1290 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1292 maybe_next_line_p
= 1;
1295 else if (line_start_position
> 0)
1301 /* Find the right column within BEST_ROW. */
1304 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1306 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1309 charpos
= glyph
->charpos
;
1316 else if (charpos
> pos
)
1318 else if (charpos
> 0)
1322 /* If we're looking for the end of the buffer,
1323 and we didn't find it in the line we scanned,
1324 use the start of the following line. */
1325 if (maybe_next_line_p
)
1332 *hpos
= lastcol
+ 1;
1336 /* Take proper action when mouse has moved to the mode or top line of
1337 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1338 mode line. X is relative to the start of the text display area of
1339 W, so the width of bitmap areas and scroll bars must be subtracted
1340 to get a position relative to the start of the mode line. */
1342 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1344 struct frame
*f
= XFRAME (w
->frame
);
1345 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1346 struct glyph_row
*row
;
1349 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1351 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1355 extern Lisp_Object Qhelp_echo
;
1356 struct glyph
*glyph
, *end
;
1357 Lisp_Object help
, map
;
1359 /* Find the glyph under X. */
1360 glyph
= row
->glyphs
[TEXT_AREA
]
1361 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1362 end
= glyph
+ row
->used
[TEXT_AREA
];
1364 && STRINGP (glyph
->object
)
1365 && XSTRING (glyph
->object
)->intervals
1366 && glyph
->charpos
>= 0
1367 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1369 /* If we're on a string with `help-echo' text property,
1370 arrange for the help to be displayed. This is done by
1371 setting the global variable help_echo to the help string. */
1372 help
= Fget_text_property (make_number (glyph
->charpos
),
1373 Qhelp_echo
, glyph
->object
);
1380 /* Take proper action when the mouse has moved to position X, Y on
1381 frame F as regards highlighting characters that have mouse-face
1382 properties. Also de-highlighting chars where the mouse was before.
1383 X and Y can be negative or out of range. */
1385 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1387 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1392 /* When a menu is active, don't highlight because this looks odd. */
1393 if (mouse_preempted
)
1396 if (disable_mouse_highlight
1397 || !f
->glyphs_initialized_p
)
1400 dpyinfo
->mouse_face_mouse_x
= x
;
1401 dpyinfo
->mouse_face_mouse_y
= y
;
1402 dpyinfo
->mouse_face_mouse_frame
= f
;
1404 if (dpyinfo
->mouse_face_defer
)
1409 dpyinfo
->mouse_face_deferred_gc
= 1;
1413 /* Which window is that in? */
1414 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1416 /* If we were displaying active text in another window, clear that. */
1417 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1418 clear_mouse_face (dpyinfo
);
1420 /* Not on a window -> return. */
1421 if (!WINDOWP (window
))
1424 /* Convert to window-relative coordinates. */
1425 w
= XWINDOW (window
);
1426 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1427 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1429 if (portion
== 1 || portion
== 3)
1431 /* Mouse is on the mode or top line. */
1432 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1436 IT_set_mouse_pointer (0);
1438 /* Are we in a window whose display is up to date?
1439 And verify the buffer's text has not changed. */
1440 if (/* Within text portion of the window. */
1442 && EQ (w
->window_end_valid
, w
->buffer
)
1443 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1444 && (XFASTINT (w
->last_overlay_modified
)
1445 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1448 struct glyph_row
*row
;
1449 struct glyph
*glyph
;
1451 /* Find the glyph under X/Y. */
1453 if (y
< w
->current_matrix
->nrows
)
1455 row
= MATRIX_ROW (w
->current_matrix
, y
);
1457 && row
->displays_text_p
1458 && x
< window_box_width (w
, TEXT_AREA
))
1460 glyph
= row
->glyphs
[TEXT_AREA
];
1461 if (x
>= row
->used
[TEXT_AREA
])
1466 if (!BUFFERP (glyph
->object
))
1472 /* Clear mouse face if X/Y not over text. */
1475 clear_mouse_face (dpyinfo
);
1479 if (!BUFFERP (glyph
->object
))
1481 pos
= glyph
->charpos
;
1483 /* Check for mouse-face and help-echo. */
1485 extern Lisp_Object Qmouse_face
;
1486 Lisp_Object mouse_face
, overlay
, position
;
1487 Lisp_Object
*overlay_vec
;
1489 struct buffer
*obuf
;
1492 /* If we get an out-of-range value, return now; avoid an error. */
1493 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1496 /* Make the window's buffer temporarily current for
1497 overlays_at and compute_char_face. */
1498 obuf
= current_buffer
;
1499 current_buffer
= XBUFFER (w
->buffer
);
1505 /* Is this char mouse-active or does it have help-echo? */
1506 XSETINT (position
, pos
);
1508 /* Put all the overlays we want in a vector in overlay_vec.
1509 Store the length in len. If there are more than 10, make
1510 enough space for all, and try again. */
1512 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1513 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1514 if (noverlays
> len
)
1517 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1518 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1521 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1523 /* Check mouse-face highlighting. */
1524 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1525 && y
>= dpyinfo
->mouse_face_beg_row
1526 && y
<= dpyinfo
->mouse_face_end_row
1527 && (y
> dpyinfo
->mouse_face_beg_row
1528 || x
>= dpyinfo
->mouse_face_beg_col
)
1529 && (y
< dpyinfo
->mouse_face_end_row
1530 || x
< dpyinfo
->mouse_face_end_col
1531 || dpyinfo
->mouse_face_past_end
)))
1533 /* Clear the display of the old active region, if any. */
1534 clear_mouse_face (dpyinfo
);
1536 /* Find highest priority overlay that has a mouse-face prop. */
1538 for (i
= 0; i
< noverlays
; i
++)
1540 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1541 if (!NILP (mouse_face
))
1543 overlay
= overlay_vec
[i
];
1548 /* If no overlay applies, get a text property. */
1550 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1553 /* Handle the overlay case. */
1554 if (! NILP (overlay
))
1556 /* Find the range of text around this char that
1557 should be active. */
1558 Lisp_Object before
, after
;
1561 before
= Foverlay_start (overlay
);
1562 after
= Foverlay_end (overlay
);
1563 /* Record this as the current active region. */
1564 fast_find_position (w
, XFASTINT (before
),
1565 &dpyinfo
->mouse_face_beg_col
,
1566 &dpyinfo
->mouse_face_beg_row
);
1567 dpyinfo
->mouse_face_past_end
1568 = !fast_find_position (w
, XFASTINT (after
),
1569 &dpyinfo
->mouse_face_end_col
,
1570 &dpyinfo
->mouse_face_end_row
);
1571 dpyinfo
->mouse_face_window
= window
;
1572 dpyinfo
->mouse_face_face_id
1573 = face_at_buffer_position (w
, pos
, 0, 0,
1574 &ignore
, pos
+ 1, 1);
1576 /* Display it as active. */
1577 show_mouse_face (dpyinfo
, 1);
1579 /* Handle the text property case. */
1580 else if (! NILP (mouse_face
))
1582 /* Find the range of text around this char that
1583 should be active. */
1584 Lisp_Object before
, after
, beginning
, end
;
1587 beginning
= Fmarker_position (w
->start
);
1588 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1589 - XFASTINT (w
->window_end_pos
)));
1591 = Fprevious_single_property_change (make_number (pos
+ 1),
1593 w
->buffer
, beginning
);
1595 = Fnext_single_property_change (position
, Qmouse_face
,
1597 /* Record this as the current active region. */
1598 fast_find_position (w
, XFASTINT (before
),
1599 &dpyinfo
->mouse_face_beg_col
,
1600 &dpyinfo
->mouse_face_beg_row
);
1601 dpyinfo
->mouse_face_past_end
1602 = !fast_find_position (w
, XFASTINT (after
),
1603 &dpyinfo
->mouse_face_end_col
,
1604 &dpyinfo
->mouse_face_end_row
);
1605 dpyinfo
->mouse_face_window
= window
;
1606 dpyinfo
->mouse_face_face_id
1607 = face_at_buffer_position (w
, pos
, 0, 0,
1608 &ignore
, pos
+ 1, 1);
1610 /* Display it as active. */
1611 show_mouse_face (dpyinfo
, 1);
1615 /* Look for a `help-echo' property. */
1618 extern Lisp_Object Qhelp_echo
;
1620 /* Check overlays first. */
1622 for (i
= 0; i
< noverlays
&& !STRINGP (help
); ++i
)
1623 help
= Foverlay_get (overlay_vec
[i
], Qhelp_echo
);
1625 /* Try text properties. */
1627 && ((STRINGP (glyph
->object
)
1628 && glyph
->charpos
>= 0
1629 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1630 || (BUFFERP (glyph
->object
)
1631 && glyph
->charpos
>= BEGV
1632 && glyph
->charpos
< ZV
)))
1633 help
= Fget_text_property (make_number (glyph
->charpos
),
1634 Qhelp_echo
, glyph
->object
);
1642 current_buffer
= obuf
;
1648 IT_clear_end_of_line (int first_unused
)
1652 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1653 extern int fatal_error_in_progress
;
1655 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1659 i
= (j
= first_unused
- new_pos_X
) * 2;
1661 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1662 spaces
= sp
= alloca (i
);
1667 *sp
++ = ScreenAttrib
;
1671 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1672 if (screen_virtual_segment
)
1673 dosv_refresh_virtual_screen (offset
, i
/ 2);
1675 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1676 Let's follow their lead, in case someone relies on this. */
1677 new_pos_X
= first_unused
;
1681 IT_clear_screen (void)
1684 fprintf (termscript
, "<CLR:SCR>");
1688 if (screen_virtual_segment
)
1689 dosv_refresh_virtual_screen (0, screen_size
);
1690 new_pos_X
= new_pos_Y
= 0;
1694 IT_clear_to_end (void)
1697 fprintf (termscript
, "<CLR:EOS>");
1699 while (new_pos_Y
< screen_size_Y
) {
1701 IT_clear_end_of_line (screen_size_X
);
1707 IT_cursor_to (int y
, int x
)
1710 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1715 static int cursor_cleared
;
1718 IT_display_cursor (int on
)
1720 if (on
&& cursor_cleared
)
1722 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1725 else if (!on
&& !cursor_cleared
)
1727 ScreenSetCursor (-1, -1);
1732 /* Emacs calls cursor-movement functions a lot when it updates the
1733 display (probably a legacy of old terminals where you cannot
1734 update a screen line without first moving the cursor there).
1735 However, cursor movement is expensive on MSDOS (it calls a slow
1736 BIOS function and requires 2 mode switches), while actual screen
1737 updates access the video memory directly and don't depend on
1738 cursor position. To avoid slowing down the redisplay, we cheat:
1739 all functions that move the cursor only set internal variables
1740 which record the cursor position, whereas the cursor is only
1741 moved to its final position whenever screen update is complete.
1743 `IT_cmgoto' is called from the keyboard reading loop and when the
1744 frame update is complete. This means that we are ready for user
1745 input, so we update the cursor position to show where the point is,
1746 and also make the mouse pointer visible.
1748 Special treatment is required when the cursor is in the echo area,
1749 to put the cursor at the end of the text displayed there. */
1752 IT_cmgoto (FRAME_PTR f
)
1754 /* Only set the cursor to where it should be if the display is
1755 already in sync with the window contents. */
1756 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1758 /* FIXME: This needs to be rewritten for the new redisplay, or
1761 static int previous_pos_X
= -1;
1763 update_cursor_pos
= 1; /* temporary!!! */
1765 /* If the display is in sync, forget any previous knowledge about
1766 cursor position. This is primarily for unexpected events like
1767 C-g in the minibuffer. */
1768 if (update_cursor_pos
&& previous_pos_X
>= 0)
1769 previous_pos_X
= -1;
1770 /* If we are in the echo area, put the cursor at the
1771 end of the echo area message. */
1772 if (!update_cursor_pos
1773 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1775 int tem_X
= current_pos_X
, dummy
;
1777 if (echo_area_glyphs
)
1779 tem_X
= echo_area_glyphs_length
;
1780 /* Save current cursor position, to be restored after the
1781 echo area message is erased. Only remember one level
1782 of previous cursor position. */
1783 if (previous_pos_X
== -1)
1784 ScreenGetCursor (&dummy
, &previous_pos_X
);
1786 else if (previous_pos_X
>= 0)
1788 /* We wind up here after the echo area message is erased.
1789 Restore the cursor position we remembered above. */
1790 tem_X
= previous_pos_X
;
1791 previous_pos_X
= -1;
1794 if (current_pos_X
!= tem_X
)
1797 update_cursor_pos
= 1;
1802 if (update_cursor_pos
1803 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1805 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1807 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1810 /* Maybe cursor is invisible, so make it visible. */
1811 IT_display_cursor (1);
1813 /* Mouse pointer should be always visible if we are waiting for
1820 IT_reassert_line_highlight (int new, int vpos
)
1826 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1828 highlight
= new_highlight
;
1829 IT_cursor_to (vpos
, 0);
1830 IT_clear_end_of_line (first_unused_hpos
);
1834 IT_update_begin (struct frame
*f
)
1836 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1842 if (f
== display_info
->mouse_face_mouse_frame
)
1844 /* Don't do highlighting for mouse motion during the update. */
1845 display_info
->mouse_face_defer
= 1;
1847 /* If F needs to be redrawn, simply forget about any prior mouse
1849 if (FRAME_GARBAGED_P (f
))
1850 display_info
->mouse_face_window
= Qnil
;
1852 /* Can we tell that this update does not affect the window
1853 where the mouse highlight is? If so, no need to turn off.
1854 Likewise, don't do anything if the frame is garbaged;
1855 in that case, the frame's current matrix that we would use
1856 is all wrong, and we will redisplay that line anyway. */
1857 if (!NILP (display_info
->mouse_face_window
)
1858 && WINDOWP (display_info
->mouse_face_window
))
1860 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1863 /* If the mouse highlight is in the window that was deleted
1864 (e.g., if it was popped by completion), clear highlight
1866 if (NILP (w
->buffer
))
1867 display_info
->mouse_face_window
= Qnil
;
1870 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1871 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
1875 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1876 clear_mouse_face (display_info
);
1879 else if (!FRAME_LIVE_P (display_info
->mouse_face_mouse_frame
))
1881 /* If the frame with mouse highlight was deleted, invalidate the
1883 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1884 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1885 display_info
->mouse_face_window
= Qnil
;
1886 display_info
->mouse_face_deferred_gc
= 0;
1887 display_info
->mouse_face_mouse_frame
= NULL
;
1894 IT_update_end (struct frame
*f
)
1897 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1900 Lisp_Object Qcursor_type
;
1903 IT_frame_up_to_date (struct frame
*f
)
1905 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1906 Lisp_Object new_cursor
, frame_desired_cursor
;
1909 if (dpyinfo
->mouse_face_deferred_gc
1910 || f
== dpyinfo
->mouse_face_mouse_frame
)
1913 if (dpyinfo
->mouse_face_mouse_frame
)
1914 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1915 dpyinfo
->mouse_face_mouse_x
,
1916 dpyinfo
->mouse_face_mouse_y
);
1917 dpyinfo
->mouse_face_deferred_gc
= 0;
1921 /* Set the cursor type to whatever they wanted. In a minibuffer
1922 window, we want the cursor to appear only if we are reading input
1923 from this window, and we want the cursor to be taken from the
1924 frame parameters. For the selected window, we use either its
1925 buffer-local value or the value from the frame parameters if the
1926 buffer doesn't define its local value for the cursor type. */
1927 sw
= XWINDOW (f
->selected_window
);
1928 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
1929 if (cursor_in_echo_area
1930 && FRAME_HAS_MINIBUF_P (f
)
1931 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
1932 && sw
== XWINDOW (echo_area_window
))
1933 new_cursor
= frame_desired_cursor
;
1936 struct buffer
*b
= XBUFFER (sw
->buffer
);
1938 if (EQ (b
->cursor_type
, Qt
))
1939 new_cursor
= frame_desired_cursor
;
1940 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
1941 new_cursor
= Fcons (Qbar
, make_number (0));
1943 new_cursor
= b
->cursor_type
;
1946 IT_set_cursor_type (f
, new_cursor
);
1948 IT_cmgoto (f
); /* position cursor when update is done */
1951 /* Copy LEN glyphs displayed on a single line whose vertical position
1952 is YPOS, beginning at horizontal position XFROM to horizontal
1953 position XTO, by moving blocks in the video memory. Used by
1954 functions that insert and delete glyphs. */
1956 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
1958 /* The offsets of source and destination relative to the
1959 conventional memorty selector. */
1960 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
1961 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
1963 if (from
== to
|| len
<= 0)
1966 _farsetsel (_dos_ds
);
1968 /* The source and destination might overlap, so we need to move
1969 glyphs non-destructively. */
1972 for ( ; len
; from
+= 2, to
+= 2, len
--)
1973 _farnspokew (to
, _farnspeekw (from
));
1977 from
+= (len
- 1) * 2;
1978 to
+= (len
- 1) * 2;
1979 for ( ; len
; from
-= 2, to
-= 2, len
--)
1980 _farnspokew (to
, _farnspeekw (from
));
1982 if (screen_virtual_segment
)
1983 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
1986 /* Insert and delete glyphs. */
1988 IT_insert_glyphs (start
, len
)
1989 register struct glyph
*start
;
1992 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
1994 /* Shift right the glyphs from the nominal cursor position to the
1995 end of this line. */
1996 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
1998 /* Now write the glyphs to be inserted. */
1999 IT_write_glyphs (start
, len
);
2003 IT_delete_glyphs (n
)
2009 /* set-window-configuration on window.c needs this. */
2011 x_set_menu_bar_lines (f
, value
, oldval
)
2013 Lisp_Object value
, oldval
;
2015 set_menu_bar_lines (f
, value
, oldval
);
2018 /* This was copied from xfns.c */
2020 Lisp_Object Qbackground_color
;
2021 Lisp_Object Qforeground_color
;
2022 Lisp_Object Qreverse
;
2023 extern Lisp_Object Qtitle
;
2025 /* IT_set_terminal_modes is called when emacs is started,
2026 resumed, and whenever the screen is redrawn! */
2029 IT_set_terminal_modes (void)
2032 fprintf (termscript
, "\n<SET_TERM>");
2035 screen_size_X
= ScreenCols ();
2036 screen_size_Y
= ScreenRows ();
2037 screen_size
= screen_size_X
* screen_size_Y
;
2039 new_pos_X
= new_pos_Y
= 0;
2040 current_pos_X
= current_pos_Y
= -1;
2042 if (term_setup_done
)
2044 term_setup_done
= 1;
2046 startup_screen_size_X
= screen_size_X
;
2047 startup_screen_size_Y
= screen_size_Y
;
2048 startup_screen_attrib
= ScreenAttrib
;
2051 /* Is DOS/V (or any other RSIS software which relocates
2052 the screen) installed? */
2054 unsigned short es_value
;
2057 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2058 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2059 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2060 else if (screen_old_address
) /* already switched to Japanese mode once */
2061 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2063 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2065 es_value
= regs
.x
.es
;
2066 __dpmi_int (0x10, ®s
);
2068 if (regs
.x
.es
!= es_value
)
2070 /* screen_old_address is only set if ScreenPrimary does NOT
2071 already point to the relocated buffer address returned by
2072 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2073 ScreenPrimary to that address at startup under DOS/V. */
2074 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2075 screen_old_address
= ScreenPrimary
;
2076 screen_virtual_segment
= regs
.x
.es
;
2077 screen_virtual_offset
= regs
.x
.di
;
2078 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2081 #endif /* __DJGPP__ > 1 */
2083 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2084 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2087 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2088 screen_size_X
, screen_size_Y
);
2093 /* IT_reset_terminal_modes is called when emacs is
2094 suspended or killed. */
2097 IT_reset_terminal_modes (void)
2099 int display_row_start
= (int) ScreenPrimary
;
2100 int saved_row_len
= startup_screen_size_X
* 2;
2101 int update_row_len
= ScreenCols () * 2;
2102 int current_rows
= ScreenRows ();
2103 int to_next_row
= update_row_len
;
2104 unsigned char *saved_row
= startup_screen_buffer
;
2105 int cursor_pos_X
= ScreenCols () - 1;
2106 int cursor_pos_Y
= ScreenRows () - 1;
2109 fprintf (termscript
, "\n<RESET_TERM>");
2113 if (!term_setup_done
)
2118 /* Leave the video system in the same state as we found it,
2119 as far as the blink/bright-background bit is concerned. */
2120 maybe_enable_blinking ();
2122 /* We have a situation here.
2123 We cannot just do ScreenUpdate(startup_screen_buffer) because
2124 the luser could have changed screen dimensions inside Emacs
2125 and failed (or didn't want) to restore them before killing
2126 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2127 thus will happily use memory outside what was allocated for
2128 `startup_screen_buffer'.
2129 Thus we only restore as much as the current screen dimensions
2130 can hold, and clear the rest (if the saved screen is smaller than
2131 the current) with the color attribute saved at startup. The cursor
2132 is also restored within the visible dimensions. */
2134 ScreenAttrib
= startup_screen_attrib
;
2136 /* Don't restore the screen if we are exiting less than 2 seconds
2137 after startup: we might be crashing, and the screen might show
2138 some vital clues to what's wrong. */
2139 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2142 if (screen_virtual_segment
)
2143 dosv_refresh_virtual_screen (0, screen_size
);
2145 if (update_row_len
> saved_row_len
)
2146 update_row_len
= saved_row_len
;
2147 if (current_rows
> startup_screen_size_Y
)
2148 current_rows
= startup_screen_size_Y
;
2151 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2152 update_row_len
/ 2, current_rows
);
2154 while (current_rows
--)
2156 dosmemput (saved_row
, update_row_len
, display_row_start
);
2157 if (screen_virtual_segment
)
2158 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2159 update_row_len
/ 2);
2160 saved_row
+= saved_row_len
;
2161 display_row_start
+= to_next_row
;
2164 if (startup_pos_X
< cursor_pos_X
)
2165 cursor_pos_X
= startup_pos_X
;
2166 if (startup_pos_Y
< cursor_pos_Y
)
2167 cursor_pos_Y
= startup_pos_Y
;
2169 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2170 xfree (startup_screen_buffer
);
2172 term_setup_done
= 0;
2176 IT_set_terminal_window (int foo
)
2180 /* Remember the screen colors of the curent frame, to serve as the
2181 default colors for newly-created frames. */
2183 static int initial_screen_colors
[2];
2185 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2186 Smsdos_remember_default_colors
, 1, 1, 0,
2187 "Remember the screen colors of the current frame.")
2194 CHECK_FRAME (frame
, 0);
2196 reverse
= EQ (Fcdr (Fassq (intern ("reverse"), f
->param_alist
)), Qt
);
2198 initial_screen_colors
[0]
2199 = reverse
? FRAME_BACKGROUND_PIXEL (f
) : FRAME_FOREGROUND_PIXEL (f
);
2200 initial_screen_colors
[1]
2201 = reverse
? FRAME_FOREGROUND_PIXEL (f
) : FRAME_BACKGROUND_PIXEL (f
);
2205 IT_set_frame_parameters (f
, alist
)
2210 int length
= XINT (Flength (alist
));
2213 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2215 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2216 /* Do we have to reverse the foreground and background colors? */
2217 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2218 int was_reverse
= reverse
;
2219 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2220 unsigned long orig_fg
;
2221 unsigned long orig_bg
;
2223 /* If we are creating a new frame, begin with the original screen colors
2224 used for the initial frame. */
2225 if (alist
== Vdefault_frame_alist
2226 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2228 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2229 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2231 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2232 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2234 /* Extract parm names and values into those vectors. */
2236 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2241 parms
[i
] = Fcar (elt
);
2242 CHECK_SYMBOL (parms
[i
], 1);
2243 values
[i
] = Fcdr (elt
);
2249 for (i
= 0; i
< j
; i
++)
2251 Lisp_Object prop
= parms
[i
];
2252 Lisp_Object val
= values
[i
];
2254 if (EQ (prop
, Qreverse
))
2255 reverse
= EQ (val
, Qt
);
2258 if (termscript
&& reverse
&& !was_reverse
)
2259 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2261 /* Now process the alist elements in reverse of specified order. */
2262 for (i
--; i
>= 0; i
--)
2264 Lisp_Object prop
= parms
[i
];
2265 Lisp_Object val
= values
[i
];
2267 if (EQ (prop
, Qforeground_color
))
2269 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2270 ? LFACE_BACKGROUND_INDEX
2271 : LFACE_FOREGROUND_INDEX
);
2272 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2273 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2274 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2277 /* FIXME: should the fore-/background of the default
2278 face change here as well? */
2279 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2281 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2285 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2288 else if (EQ (prop
, Qbackground_color
))
2290 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2291 ? LFACE_FOREGROUND_INDEX
2292 : LFACE_BACKGROUND_INDEX
);
2293 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2294 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2295 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2298 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2300 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2304 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2307 else if (EQ (prop
, Qtitle
))
2309 x_set_title (f
, val
);
2311 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2313 else if (EQ (prop
, Qcursor_type
))
2315 IT_set_cursor_type (f
, val
);
2317 fprintf (termscript
, "<CTYPE: %s>\n",
2318 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2321 store_frame_param (f
, prop
, val
);
2324 /* If they specified "reverse", but not the colors, we need to swap
2325 the current frame colors. */
2326 if (reverse
&& !was_reverse
)
2330 FRAME_BACKGROUND_PIXEL (f
) = orig_fg
;
2335 FRAME_FOREGROUND_PIXEL (f
) = orig_bg
;
2342 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2343 if (f
== SELECTED_FRAME())
2348 extern void init_frame_faces (FRAME_PTR
);
2350 #endif /* !HAVE_X_WINDOWS */
2353 /* Do we need the internal terminal? */
2356 internal_terminal_init ()
2358 char *term
= getenv ("TERM");
2360 struct frame
*sf
= SELECTED_FRAME();
2362 #ifdef HAVE_X_WINDOWS
2363 if (!inhibit_window_system
)
2368 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2370 if (getenv ("EMACSTEST"))
2371 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2373 #ifndef HAVE_X_WINDOWS
2374 if (!internal_terminal
|| inhibit_window_system
)
2376 sf
->output_method
= output_termcap
;
2380 Vwindow_system
= intern ("pc");
2381 Vwindow_system_version
= make_number (1);
2382 sf
->output_method
= output_msdos_raw
;
2384 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2385 screen_old_address
= 0;
2387 /* Forget the stale screen colors as well. */
2388 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2390 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2391 the_only_x_display
.background_pixel
= 7; /* White */
2392 the_only_x_display
.foreground_pixel
= 0; /* Black */
2394 colors
= getenv ("EMACSCOLORS");
2395 if (colors
&& strlen (colors
) >= 2)
2397 /* The colors use 4 bits each (we enable bright background). */
2398 if (isdigit (colors
[0]))
2400 else if (isxdigit (colors
[0]))
2401 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2402 if (colors
[0] >= 0 && colors
[0] < 16)
2403 the_only_x_display
.foreground_pixel
= colors
[0];
2404 if (isdigit (colors
[1]))
2406 else if (isxdigit (colors
[1]))
2407 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2408 if (colors
[1] >= 0 && colors
[1] < 16)
2409 the_only_x_display
.background_pixel
= colors
[1];
2411 the_only_x_display
.line_height
= 1;
2412 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2413 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2414 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2415 the_only_x_display
.display_info
.mouse_face_beg_row
=
2416 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2417 the_only_x_display
.display_info
.mouse_face_end_row
=
2418 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2419 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2420 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2421 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2422 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2423 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2425 init_frame_faces (sf
);
2427 ring_bell_hook
= IT_ring_bell
;
2428 insert_glyphs_hook
= IT_insert_glyphs
;
2429 delete_glyphs_hook
= IT_delete_glyphs
;
2430 write_glyphs_hook
= IT_write_glyphs
;
2431 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2432 clear_to_end_hook
= IT_clear_to_end
;
2433 clear_end_of_line_hook
= IT_clear_end_of_line
;
2434 clear_frame_hook
= IT_clear_screen
;
2435 change_line_highlight_hook
= IT_change_line_highlight
;
2436 update_begin_hook
= IT_update_begin
;
2437 update_end_hook
= IT_update_end
;
2438 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2439 frame_up_to_date_hook
= IT_frame_up_to_date
;
2441 /* These hooks are called by term.c without being checked. */
2442 set_terminal_modes_hook
= IT_set_terminal_modes
;
2443 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2444 set_terminal_window_hook
= IT_set_terminal_window
;
2445 char_ins_del_ok
= 0;
2449 dos_get_saved_screen (screen
, rows
, cols
)
2454 #ifndef HAVE_X_WINDOWS
2455 *screen
= startup_screen_buffer
;
2456 *cols
= startup_screen_size_X
;
2457 *rows
= startup_screen_size_Y
;
2458 return *screen
!= (char *)0;
2464 #ifndef HAVE_X_WINDOWS
2466 /* We are not X, but we can emulate it well enough for our needs... */
2470 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2471 error ("Not running under a window system");
2477 /* ----------------------- Keyboard control ----------------------
2479 * Keymaps reflect the following keyboard layout:
2481 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2482 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2483 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2484 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2488 #define Ignore 0x0000
2489 #define Normal 0x0000 /* normal key - alt changes scan-code */
2490 #define FctKey 0x1000 /* func key if c == 0, else c */
2491 #define Special 0x2000 /* func key even if c != 0 */
2492 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2493 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2494 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2495 #define Grey 0x6000 /* Grey keypad key */
2497 #define Alt 0x0100 /* alt scan-code */
2498 #define Ctrl 0x0200 /* ctrl scan-code */
2499 #define Shift 0x0400 /* shift scan-code */
2501 static int extended_kbd
; /* 101 (102) keyboard present. */
2503 struct kbd_translate
{
2506 unsigned short code
;
2509 struct dos_keyboard_map
2514 struct kbd_translate
*translate_table
;
2518 static struct dos_keyboard_map us_keyboard
= {
2520 /* 01234567890123456789012345678901234567890 12345678901234 */
2521 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2522 /* 0123456789012345678901234567890123456789 012345678901234 */
2523 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2524 0, /* no Alt-Gr key */
2525 0 /* no translate table */
2528 static struct dos_keyboard_map fr_keyboard
= {
2530 /* 012 3456789012345678901234567890123456789012345678901234 */
2531 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2532 /* 0123456789012345678901234567890123456789012345678901234 */
2533 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2534 /* 01234567 89012345678901234567890123456789012345678901234 */
2536 0 /* no translate table */
2540 * Italian keyboard support, country code 39.
2543 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2544 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2547 static struct kbd_translate it_kbd_translate_table
[] = {
2548 { 0x56, 0x3c, Normal
| 13 },
2549 { 0x56, 0x3e, Normal
| 27 },
2552 static struct dos_keyboard_map it_keyboard
= {
2554 /* 0 123456789012345678901234567890123456789012345678901234 */
2555 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2556 /* 01 23456789012345678901234567890123456789012345678901234 */
2557 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2558 /* 0123456789012345678901234567890123456789012345678901234 */
2560 it_kbd_translate_table
2563 static struct dos_keyboard_map dk_keyboard
= {
2565 /* 0123456789012345678901234567890123456789012345678901234 */
2566 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2567 /* 01 23456789012345678901234567890123456789012345678901234 */
2568 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2569 /* 0123456789012345678901234567890123456789012345678901234 */
2571 0 /* no translate table */
2574 static struct kbd_translate jp_kbd_translate_table
[] = {
2575 { 0x73, 0x5c, Normal
| 0 },
2576 { 0x73, 0x5f, Normal
| 0 },
2577 { 0x73, 0x1c, Map
| 0 },
2578 { 0x7d, 0x5c, Normal
| 13 },
2579 { 0x7d, 0x7c, Normal
| 13 },
2580 { 0x7d, 0x1c, Map
| 13 },
2583 static struct dos_keyboard_map jp_keyboard
= {
2585 /* 0123456789012 345678901234567890123456789012345678901234 */
2586 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2587 /* 01 23456789012345678901234567890123456789012345678901234 */
2588 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2589 0, /* no Alt-Gr key */
2590 jp_kbd_translate_table
2593 static struct keyboard_layout_list
2596 struct dos_keyboard_map
*keyboard_map
;
2597 } keyboard_layout_list
[] =
2606 static struct dos_keyboard_map
*keyboard
;
2607 static int keyboard_map_all
;
2608 static int international_keyboard
;
2611 dos_set_keyboard (code
, always
)
2616 _go32_dpmi_registers regs
;
2618 /* See if Keyb.Com is installed (for international keyboard support).
2619 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2620 of Windows 9X! So don't do that! */
2622 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2623 _go32_dpmi_simulate_int (0x2f, ®s
);
2624 if (regs
.h
.al
== 0xff)
2625 international_keyboard
= 1;
2627 /* Initialize to US settings, for countries that don't have their own. */
2628 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2629 keyboard_map_all
= always
;
2630 dos_keyboard_layout
= 1;
2632 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2633 if (code
== keyboard_layout_list
[i
].country_code
)
2635 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2636 keyboard_map_all
= always
;
2637 dos_keyboard_layout
= code
;
2645 unsigned char char_code
; /* normal code */
2646 unsigned char meta_code
; /* M- code */
2647 unsigned char keypad_code
; /* keypad code */
2648 unsigned char editkey_code
; /* edit key */
2649 } keypad_translate_map
[] = {
2650 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2651 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2652 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2653 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2654 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2655 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2656 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2657 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2658 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2659 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2660 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2665 unsigned char char_code
; /* normal code */
2666 unsigned char keypad_code
; /* keypad code */
2667 } grey_key_translate_map
[] = {
2668 '/', 0xaf, /* kp-decimal */
2669 '*', 0xaa, /* kp-multiply */
2670 '-', 0xad, /* kp-subtract */
2671 '+', 0xab, /* kp-add */
2672 '\r', 0x8d /* kp-enter */
2675 static unsigned short
2676 ibmpc_translate_map
[] =
2678 /* --------------- 00 to 0f --------------- */
2679 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2680 Alt
| ModFct
| 0x1b, /* Escape */
2681 Normal
| 1, /* '1' */
2682 Normal
| 2, /* '2' */
2683 Normal
| 3, /* '3' */
2684 Normal
| 4, /* '4' */
2685 Normal
| 5, /* '5' */
2686 Normal
| 6, /* '6' */
2687 Normal
| 7, /* '7' */
2688 Normal
| 8, /* '8' */
2689 Normal
| 9, /* '9' */
2690 Normal
| 10, /* '0' */
2691 Normal
| 11, /* '-' */
2692 Normal
| 12, /* '=' */
2693 Special
| 0x08, /* Backspace */
2694 ModFct
| 0x74, /* Tab/Backtab */
2696 /* --------------- 10 to 1f --------------- */
2709 ModFct
| 0x0d, /* Return */
2714 /* --------------- 20 to 2f --------------- */
2723 Map
| 40, /* '\'' */
2725 Ignore
, /* Left shift */
2726 Map
| 41, /* '\\' */
2732 /* --------------- 30 to 3f --------------- */
2739 Ignore
, /* Right shift */
2740 Grey
| 1, /* Grey * */
2742 Normal
| 55, /* ' ' */
2743 Ignore
, /* Caps Lock */
2744 FctKey
| 0xbe, /* F1 */
2745 FctKey
| 0xbf, /* F2 */
2746 FctKey
| 0xc0, /* F3 */
2747 FctKey
| 0xc1, /* F4 */
2748 FctKey
| 0xc2, /* F5 */
2750 /* --------------- 40 to 4f --------------- */
2751 FctKey
| 0xc3, /* F6 */
2752 FctKey
| 0xc4, /* F7 */
2753 FctKey
| 0xc5, /* F8 */
2754 FctKey
| 0xc6, /* F9 */
2755 FctKey
| 0xc7, /* F10 */
2756 Ignore
, /* Num Lock */
2757 Ignore
, /* Scroll Lock */
2758 KeyPad
| 7, /* Home */
2759 KeyPad
| 8, /* Up */
2760 KeyPad
| 9, /* Page Up */
2761 Grey
| 2, /* Grey - */
2762 KeyPad
| 4, /* Left */
2763 KeyPad
| 5, /* Keypad 5 */
2764 KeyPad
| 6, /* Right */
2765 Grey
| 3, /* Grey + */
2766 KeyPad
| 1, /* End */
2768 /* --------------- 50 to 5f --------------- */
2769 KeyPad
| 2, /* Down */
2770 KeyPad
| 3, /* Page Down */
2771 KeyPad
| 0, /* Insert */
2772 KeyPad
| 10, /* Delete */
2773 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2774 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2775 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2776 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2777 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2778 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2779 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2780 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2781 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2782 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2783 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2784 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2786 /* --------------- 60 to 6f --------------- */
2787 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2788 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2789 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2790 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2791 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2792 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2793 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2794 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2795 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2796 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2797 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2798 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2799 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2800 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2801 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2802 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2804 /* --------------- 70 to 7f --------------- */
2805 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2806 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2807 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2808 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2809 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2810 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2811 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2812 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2813 Alt
| Map
| 1, /* '1' */
2814 Alt
| Map
| 2, /* '2' */
2815 Alt
| Map
| 3, /* '3' */
2816 Alt
| Map
| 4, /* '4' */
2817 Alt
| Map
| 5, /* '5' */
2818 Alt
| Map
| 6, /* '6' */
2819 Alt
| Map
| 7, /* '7' */
2820 Alt
| Map
| 8, /* '8' */
2822 /* --------------- 80 to 8f --------------- */
2823 Alt
| Map
| 9, /* '9' */
2824 Alt
| Map
| 10, /* '0' */
2825 Alt
| Map
| 11, /* '-' */
2826 Alt
| Map
| 12, /* '=' */
2827 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2828 FctKey
| 0xc8, /* F11 */
2829 FctKey
| 0xc9, /* F12 */
2830 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2831 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2832 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2833 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2834 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2835 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2836 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2837 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2838 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2840 /* --------------- 90 to 9f --------------- */
2841 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2842 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2843 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2844 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2845 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2846 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2847 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2848 Alt
| FctKey
| 0x50, /* (Alt) Home */
2849 Alt
| FctKey
| 0x52, /* (Alt) Up */
2850 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2851 Ignore
, /* NO KEY */
2852 Alt
| FctKey
| 0x51, /* (Alt) Left */
2853 Ignore
, /* NO KEY */
2854 Alt
| FctKey
| 0x53, /* (Alt) Right */
2855 Ignore
, /* NO KEY */
2856 Alt
| FctKey
| 0x57, /* (Alt) End */
2858 /* --------------- a0 to af --------------- */
2859 Alt
| KeyPad
| 2, /* (Alt) Down */
2860 Alt
| KeyPad
| 3, /* (Alt) Page Down */
2861 Alt
| KeyPad
| 0, /* (Alt) Insert */
2862 Alt
| KeyPad
| 10, /* (Alt) Delete */
2863 Alt
| Grey
| 0, /* (Alt) Grey / */
2864 Alt
| FctKey
| 0x09, /* (Alt) Tab */
2865 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
2868 /* These bit-positions corresponds to values returned by BIOS */
2869 #define SHIFT_P 0x0003 /* two bits! */
2870 #define CTRL_P 0x0004
2871 #define ALT_P 0x0008
2872 #define SCRLOCK_P 0x0010
2873 #define NUMLOCK_P 0x0020
2874 #define CAPSLOCK_P 0x0040
2875 #define ALT_GR_P 0x0800
2876 #define SUPER_P 0x4000 /* pseudo */
2877 #define HYPER_P 0x8000 /* pseudo */
2880 dos_get_modifiers (keymask
)
2887 /* Calculate modifier bits */
2888 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
2889 int86 (0x16, ®s
, ®s
);
2893 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
2894 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2898 mask
= regs
.h
.al
& (SHIFT_P
|
2899 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2901 /* Do not break international keyboard support. */
2902 /* When Keyb.Com is loaded, the right Alt key is */
2903 /* used for accessing characters like { and } */
2904 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
2907 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
2910 if (dos_hyper_key
== 1)
2913 modifiers
|= hyper_modifier
;
2915 else if (dos_super_key
== 1)
2918 modifiers
|= super_modifier
;
2920 else if (!international_keyboard
)
2922 /* If Keyb.Com is NOT installed, let Right Alt behave
2923 like the Left Alt. */
2929 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
2932 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
2934 if (dos_hyper_key
== 2)
2937 modifiers
|= hyper_modifier
;
2939 else if (dos_super_key
== 2)
2942 modifiers
|= super_modifier
;
2950 modifiers
|= shift_modifier
;
2952 modifiers
|= ctrl_modifier
;
2954 modifiers
|= meta_modifier
;
2961 #define NUM_RECENT_DOSKEYS (100)
2962 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
2963 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
2964 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
2966 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
2967 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
2968 Each input key receives two values in this vector: first the ASCII code,\n\
2969 and then the scan code.")
2972 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
2975 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
2976 return Fvector (total_doskeys
, keys
);
2979 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
2980 bcopy (keys
+ recent_doskeys_index
,
2981 XVECTOR (val
)->contents
,
2982 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
2984 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
2985 recent_doskeys_index
* sizeof (Lisp_Object
));
2990 /* Get a char from keyboard. Function keys are put into the event queue. */
2992 extern void kbd_buffer_store_event (struct input_event
*);
2997 struct input_event event
;
3000 #ifndef HAVE_X_WINDOWS
3001 /* Maybe put the cursor where it should be. */
3002 IT_cmgoto (SELECTED_FRAME());
3005 /* The following condition is equivalent to `kbhit ()', except that
3006 it uses the bios to do its job. This pleases DESQview/X. */
3007 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3008 int86 (0x16, ®s
, ®s
),
3009 (regs
.x
.flags
& 0x40) == 0)
3012 register unsigned char c
;
3013 int sc
, code
= -1, mask
, kp_mode
;
3016 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3017 int86 (0x16, ®s
, ®s
);
3022 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3024 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3025 recent_doskeys_index
= 0;
3026 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3028 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3029 recent_doskeys_index
= 0;
3031 modifiers
= dos_get_modifiers (&mask
);
3033 #ifndef HAVE_X_WINDOWS
3034 if (!NILP (Vdos_display_scancodes
))
3037 sprintf (buf
, "%02x:%02x*%04x",
3038 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3039 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3047 case 10: /* Ctrl Grey Enter */
3048 code
= Ctrl
| Grey
| 4;
3050 case 13: /* Grey Enter */
3053 case '/': /* Grey / */
3063 /* Try the keyboard-private translation table first. */
3064 if (keyboard
->translate_table
)
3066 struct kbd_translate
*p
= keyboard
->translate_table
;
3070 if (p
->sc
== sc
&& p
->ch
== c
)
3078 /* If the private table didn't translate it, use the general
3082 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3084 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3091 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3092 Emacs is ready to read a key. Therefore, if they press
3093 `Alt-x' when Emacs is busy, by the time we get to
3094 `dos_get_modifiers', they might have already released the
3095 Alt key, and Emacs gets just `x', which is BAD.
3096 However, for keys with the `Map' property set, the ASCII
3097 code returns zero iff Alt is pressed. So, when we DON'T
3098 have to support international_keyboard, we don't have to
3099 distinguish between the left and right Alt keys, and we
3100 can set the META modifier for any keys with the `Map'
3101 property if they return zero ASCII code (c = 0). */
3103 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3104 modifiers
|= meta_modifier
;
3106 modifiers
|= ctrl_modifier
;
3108 modifiers
|= shift_modifier
;
3111 switch (code
& 0xf000)
3114 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3116 c
= 0; /* Special */
3129 if (c
== 0) /* ctrl-break */
3131 return c
; /* ALT-nnn */
3133 if (!keyboard_map_all
)
3142 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3143 if (!keyboard_map_all
)
3147 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3148 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3152 code
= keyboard
->shifted
[code
];
3154 modifiers
&= ~shift_modifier
;
3157 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3158 code
= keyboard
->alt_gr
[code
];
3160 code
= keyboard
->unshifted
[code
];
3165 if (c
== 0xe0) /* edit key */
3168 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3169 kp_mode
= dos_keypad_mode
& 0x03;
3171 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3176 if (code
== 10 && dos_decimal_point
)
3177 return dos_decimal_point
;
3178 return keypad_translate_map
[code
].char_code
;
3181 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3185 code
= keypad_translate_map
[code
].meta_code
;
3186 modifiers
= meta_modifier
;
3190 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3197 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3198 if (dos_keypad_mode
& kp_mode
)
3199 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3201 code
= grey_key_translate_map
[code
].char_code
;
3210 event
.kind
= non_ascii_keystroke
;
3212 event
.kind
= ascii_keystroke
;
3214 event
.modifiers
= modifiers
;
3215 event
.frame_or_window
= selected_frame
;
3216 event
.timestamp
= event_timestamp ();
3217 kbd_buffer_store_event (&event
);
3220 if (have_mouse
> 0 && !mouse_preempted
)
3222 int but
, press
, x
, y
, ok
;
3223 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3225 /* Check for mouse movement *before* buttons. */
3226 mouse_check_moved ();
3228 /* If the mouse moved from the spot of its last sighting, we
3229 might need to update mouse highlight. */
3230 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3232 previous_help_echo
= help_echo
;
3234 IT_note_mouse_highlight (SELECTED_FRAME(),
3235 mouse_last_x
, mouse_last_y
);
3236 /* If the contents of the global variable help_echo has
3237 changed, generate a HELP_EVENT. */
3238 if (STRINGP (help_echo
) || STRINGP (previous_help_echo
))
3240 event
.kind
= HELP_EVENT
;
3241 event
.frame_or_window
= Fcons (selected_frame
, help_echo
);
3242 event
.timestamp
= event_timestamp ();
3243 kbd_buffer_store_event (&event
);
3247 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3248 for (press
= 0; press
< 2; press
++)
3250 int button_num
= but
;
3253 ok
= mouse_pressed (but
, &x
, &y
);
3255 ok
= mouse_released (but
, &x
, &y
);
3258 /* Allow a simultaneous press/release of Mouse-1 and
3259 Mouse-2 to simulate Mouse-3 on two-button mice. */
3260 if (mouse_button_count
== 2 && but
< 2)
3262 int x2
, y2
; /* don't clobber original coordinates */
3264 /* If only one button is pressed, wait 100 msec and
3265 check again. This way, Speedy Gonzales isn't
3266 punished, while the slow get their chance. */
3267 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3268 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3273 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3274 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3279 event
.kind
= mouse_click
;
3280 event
.code
= button_num
;
3281 event
.modifiers
= dos_get_modifiers (0)
3282 | (press
? down_modifier
: up_modifier
);
3285 event
.frame_or_window
= selected_frame
;
3286 event
.timestamp
= event_timestamp ();
3287 kbd_buffer_store_event (&event
);
3295 static int prev_get_char
= -1;
3297 /* Return 1 if a key is ready to be read without suspending execution. */
3301 if (prev_get_char
!= -1)
3304 return ((prev_get_char
= dos_rawgetc ()) != -1);
3307 /* Read a key. Return -1 if no key is ready. */
3311 if (prev_get_char
!= -1)
3313 int c
= prev_get_char
;
3318 return dos_rawgetc ();
3321 #ifndef HAVE_X_WINDOWS
3322 /* See xterm.c for more info. */
3324 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3326 register int pix_x
, pix_y
;
3327 register int *x
, *y
;
3331 if (bounds
) abort ();
3333 /* Ignore clipping. */
3340 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3343 register int *pix_x
, *pix_y
;
3349 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3352 Actually, I don't know the meaning of all the parameters of the functions
3353 here -- I only know how they are called by xmenu.c. I could of course
3354 grab the nearest Xlib manual (down the hall, second-to-last door on the
3355 left), but I don't think it's worth the effort. */
3357 static char *menu_help_message
, *prev_menu_help_message
;
3364 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3365 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3369 /* Allocate some (more) memory for MENU ensuring that there is room for one
3373 IT_menu_make_room (XMenu
*menu
)
3375 if (menu
->allocated
== 0)
3377 int count
= menu
->allocated
= 10;
3378 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3379 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3380 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3381 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3383 else if (menu
->allocated
== menu
->count
)
3385 int count
= menu
->allocated
= menu
->allocated
+ 10;
3387 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3389 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3391 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3393 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3397 /* Search the given menu structure for a given pane number. */
3400 IT_menu_search_pane (XMenu
*menu
, int pane
)
3405 for (i
= 0; i
< menu
->count
; i
++)
3406 if (menu
->submenu
[i
])
3408 if (pane
== menu
->panenumber
[i
])
3409 return menu
->submenu
[i
];
3410 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3416 /* Determine how much screen space a given menu needs. */
3419 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3421 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3424 maxheight
= menu
->count
;
3425 for (i
= 0; i
< menu
->count
; i
++)
3427 if (menu
->submenu
[i
])
3429 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3430 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3431 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3434 *width
= menu
->width
+ maxsubwidth
;
3435 *height
= maxheight
;
3438 /* Display MENU at (X,Y) using FACES. */
3441 IT_menu_display (XMenu
*menu
, int y
, int x
, int *faces
, int disp_help
)
3443 int i
, j
, face
, width
;
3444 struct glyph
*text
, *p
;
3447 int enabled
, mousehere
;
3449 struct frame
*sf
= SELECTED_FRAME();
3451 menu_help_message
= NULL
;
3453 width
= menu
->width
;
3454 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3455 ScreenGetCursor (&row
, &col
);
3456 mouse_get_xy (&mx
, &my
);
3457 IT_update_begin (sf
);
3458 for (i
= 0; i
< menu
->count
; i
++)
3460 int max_width
= width
+ 2;
3462 IT_cursor_to (y
+ i
, x
);
3464 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3465 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3466 face
= faces
[enabled
+ mousehere
* 2];
3467 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3468 menu_help_message
= menu
->help_text
[i
];
3470 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3472 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3476 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3479 else /* make '^x' */
3481 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3484 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3488 /* Don't let the menu text overflow into the next screen row. */
3489 if (x
+ max_width
> screen_size_X
)
3491 max_width
= screen_size_X
- x
;
3492 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3494 for (; j
< max_width
- 2; j
++, p
++)
3495 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3497 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3499 IT_write_glyphs (text
, max_width
);
3502 IT_cursor_to (row
, col
);
3506 /* --------------------------- X Menu emulation ---------------------- */
3508 /* Report availability of menus. */
3516 /* Create a brand new menu structure. */
3519 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3521 return IT_menu_create ();
3524 /* Create a new pane and place it on the outer-most level. It is not
3525 clear that it should be placed out there, but I don't know what else
3529 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3537 IT_menu_make_room (menu
);
3538 menu
->submenu
[menu
->count
] = IT_menu_create ();
3539 menu
->text
[menu
->count
] = txt
;
3540 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3541 menu
->help_text
[menu
->count
] = NULL
;
3544 /* Adjust length for possible control characters (which will
3545 be written as ^x). */
3546 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3550 if (len
> menu
->width
)
3553 return menu
->panecount
;
3556 /* Create a new item in a menu pane. */
3559 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3560 int foo
, char *txt
, int enable
, char *help_text
)
3566 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3568 IT_menu_make_room (menu
);
3569 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3570 menu
->text
[menu
->count
] = txt
;
3571 menu
->panenumber
[menu
->count
] = enable
;
3572 menu
->help_text
[menu
->count
] = help_text
;
3575 /* Adjust length for possible control characters (which will
3576 be written as ^x). */
3577 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3581 if (len
> menu
->width
)
3587 /* Decide where the menu would be placed if requested at (X,Y). */
3590 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3591 int *ulx
, int *uly
, int *width
, int *height
)
3593 IT_menu_calc_size (menu
, width
, height
);
3599 struct IT_menu_state
3601 void *screen_behind
;
3608 /* Display menu, wait for user's response, and return that response. */
3611 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3612 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3613 void (*help_callback
)(char *))
3615 struct IT_menu_state
*state
;
3620 Lisp_Object selectface
;
3621 int leave
, result
, onepane
;
3622 int title_faces
[4]; /* face to display the menu title */
3623 int buffers_num_deleted
= 0;
3624 struct frame
*sf
= SELECTED_FRAME();
3626 /* Just in case we got here without a mouse present... */
3627 if (have_mouse
<= 0)
3628 return XM_IA_SELECT
;
3629 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3630 around the display. */
3636 /* We will process all the mouse events directly, so we had
3637 better prevented dos_rawgetc from stealing them from us. */
3640 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3641 screensize
= screen_size
* 2;
3643 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3644 0, DEFAULT_FACE_ID
);
3646 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3647 0, DEFAULT_FACE_ID
);
3648 selectface
= intern ("msdos-menu-select-face");
3649 faces
[2] = lookup_derived_face (sf
, selectface
,
3651 faces
[3] = lookup_derived_face (sf
, selectface
,
3654 /* Make sure the menu title is always displayed with
3655 `msdos-menu-active-face', no matter where the mouse pointer is. */
3656 for (i
= 0; i
< 4; i
++)
3657 title_faces
[i
] = faces
[3];
3661 /* Don't let the title for the "Buffers" popup menu include a
3662 digit (which is ugly).
3664 This is a terrible kludge, but I think the "Buffers" case is
3665 the only one where the title includes a number, so it doesn't
3666 seem to be necessary to make this more general. */
3667 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3669 menu
->text
[0][7] = '\0';
3670 buffers_num_deleted
= 1;
3672 state
[0].menu
= menu
;
3674 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3676 /* Turn off the cursor. Otherwise it shows through the menu
3677 panes, which is ugly. */
3678 IT_display_cursor (0);
3680 /* Display the menu title. */
3681 IT_menu_display (menu
, y0
- 1, x0
- 1, title_faces
, 0);
3682 if (buffers_num_deleted
)
3683 menu
->text
[0][7] = ' ';
3684 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3686 menu
->width
= menu
->submenu
[0]->width
;
3687 state
[0].menu
= menu
->submenu
[0];
3691 state
[0].menu
= menu
;
3693 state
[0].x
= x0
- 1;
3695 state
[0].pane
= onepane
;
3697 mouse_last_x
= -1; /* A hack that forces display. */
3701 if (!mouse_visible
) mouse_on ();
3702 mouse_check_moved ();
3703 if (sf
->mouse_moved
)
3705 sf
->mouse_moved
= 0;
3706 result
= XM_IA_SELECT
;
3707 mouse_get_xy (&x
, &y
);
3708 for (i
= 0; i
< statecount
; i
++)
3709 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3711 int dy
= y
- state
[i
].y
;
3712 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3714 if (!state
[i
].menu
->submenu
[dy
])
3715 if (state
[i
].menu
->panenumber
[dy
])
3716 result
= XM_SUCCESS
;
3718 result
= XM_IA_SELECT
;
3719 *pane
= state
[i
].pane
- 1;
3721 /* We hit some part of a menu, so drop extra menus that
3722 have been opened. That does not include an open and
3724 if (i
!= statecount
- 2
3725 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3726 while (i
!= statecount
- 1)
3730 ScreenUpdate (state
[statecount
].screen_behind
);
3731 if (screen_virtual_segment
)
3732 dosv_refresh_virtual_screen (0, screen_size
);
3733 xfree (state
[statecount
].screen_behind
);
3735 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3737 IT_menu_display (state
[i
].menu
,
3741 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3742 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3744 ScreenRetrieve (state
[statecount
].screen_behind
3745 = xmalloc (screensize
));
3747 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3748 state
[statecount
].y
= y
;
3753 IT_menu_display (state
[statecount
- 1].menu
,
3754 state
[statecount
- 1].y
,
3755 state
[statecount
- 1].x
,
3760 if ((menu_help_message
|| prev_menu_help_message
)
3761 && menu_help_message
!= prev_menu_help_message
)
3763 help_callback (menu_help_message
);
3764 IT_display_cursor (0);
3765 prev_menu_help_message
= menu_help_message
;
3767 /* We are busy-waiting for the mouse to move, so let's be nice
3768 to other Windows applications by releasing our time slice. */
3771 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3773 /* Only leave if user both pressed and released the mouse, and in
3774 that order. This avoids popping down the menu pane unless
3775 the user is really done with it. */
3776 if (mouse_pressed (b
, &x
, &y
))
3778 while (mouse_button_depressed (b
, &x
, &y
))
3782 (void) mouse_released (b
, &x
, &y
);
3787 ScreenUpdate (state
[0].screen_behind
);
3788 if (screen_virtual_segment
)
3789 dosv_refresh_virtual_screen (0, screen_size
);
3791 while (statecount
--)
3792 xfree (state
[statecount
].screen_behind
);
3793 IT_display_cursor (1); /* turn cursor back on */
3794 /* Clean up any mouse events that are waiting inside Emacs event queue.
3795 These events are likely to be generated before the menu was even
3796 displayed, probably because the user pressed and released the button
3797 (which invoked the menu) too quickly. If we don't remove these events,
3798 Emacs will process them after we return and surprise the user. */
3799 discard_mouse_events ();
3800 /* Allow mouse events generation by dos_rawgetc. */
3805 /* Dispose of a menu. */
3808 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3811 if (menu
->allocated
)
3813 for (i
= 0; i
< menu
->count
; i
++)
3814 if (menu
->submenu
[i
])
3815 XMenuDestroy (foo
, menu
->submenu
[i
]);
3817 xfree (menu
->submenu
);
3818 xfree (menu
->panenumber
);
3819 xfree (menu
->help_text
);
3822 menu_help_message
= prev_menu_help_message
= NULL
;
3826 x_pixel_width (struct frame
*f
)
3828 return FRAME_WIDTH (f
);
3832 x_pixel_height (struct frame
*f
)
3834 return FRAME_HEIGHT (f
);
3836 #endif /* !HAVE_X_WINDOWS */
3838 /* ----------------------- DOS / UNIX conversion --------------------- */
3840 void msdos_downcase_filename (unsigned char *);
3842 /* Destructively turn backslashes into slashes. */
3845 dostounix_filename (p
)
3848 msdos_downcase_filename (p
);
3858 /* Destructively turn slashes into backslashes. */
3861 unixtodos_filename (p
)
3864 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3878 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
3881 getdefdir (drive
, dst
)
3885 char in_path
[4], *p
= in_path
;
3888 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
3891 *p
++ = drive
+ 'A' - 1;
3898 _fixpath (in_path
, dst
);
3899 /* _fixpath can set errno to ENOSYS on non-LFN systems because
3900 it queries the LFN support, so ignore that error. */
3901 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
3904 msdos_downcase_filename (dst
);
3910 /* Remove all CR's that are followed by a LF. */
3915 register unsigned char *buf
;
3917 unsigned char *np
= buf
;
3918 unsigned char *startp
= buf
;
3919 unsigned char *endp
= buf
+ n
;
3923 while (buf
< endp
- 1)
3927 if (*(++buf
) != 0x0a)
3938 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
3940 /* In DJGPP v2.0, library `write' can call `malloc', which might
3941 cause relocation of the buffer whose address we get in ADDR.
3942 Here is a version of `write' that avoids calling `malloc',
3943 to serve us until such time as the library is fixed.
3944 Actually, what we define here is called `__write', because
3945 `write' is a stub that just jmp's to `__write' (to be
3946 POSIXLY-correct with respect to the global name-space). */
3948 #include <io.h> /* for _write */
3949 #include <libc/dosio.h> /* for __file_handle_modes[] */
3951 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
3953 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
3956 __write (int handle
, const void *buffer
, size_t count
)
3961 if(__file_handle_modes
[handle
] & O_BINARY
)
3962 return _write (handle
, buffer
, count
);
3966 const char *bp
= buffer
;
3967 int total_written
= 0;
3968 int nmoved
= 0, ncr
= 0;
3972 /* The next test makes sure there's space for at least 2 more
3973 characters in xbuf[], so both CR and LF can be put there. */
3985 if (xbp
>= XBUF_END
|| !count
)
3987 size_t to_write
= nmoved
+ ncr
;
3988 int written
= _write (handle
, xbuf
, to_write
);
3993 total_written
+= nmoved
; /* CRs aren't counted in ret value */
3995 /* If some, but not all were written (disk full?), return
3996 an estimate of the total written bytes not counting CRs. */
3997 if (written
< to_write
)
3998 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4005 return total_written
;
4009 /* A low-level file-renaming function which works around Windows 95 bug.
4010 This is pulled directly out of DJGPP v2.01 library sources, and only
4011 used when you compile with DJGPP v2.0. */
4015 int _rename(const char *old
, const char *new)
4018 int olen
= strlen(old
) + 1;
4020 int use_lfn
= _USE_LFN
;
4021 char tempfile
[FILENAME_MAX
];
4022 const char *orig
= old
;
4025 r
.x
.dx
= __tb_offset
;
4026 r
.x
.di
= __tb_offset
+ olen
;
4027 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4031 /* Windows 95 bug: for some filenames, when you rename
4032 file -> file~ (as in Emacs, to leave a backup), the
4033 short 8+3 alias doesn't change, which effectively
4034 makes OLD and NEW the same file. We must rename
4035 through a temporary file to work around this. */
4037 char *pbase
= 0, *p
;
4038 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4039 int idx
= sizeof(try_char
) - 1;
4041 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4042 might point to another drive, which will fail the DOS call. */
4043 strcpy(tempfile
, old
);
4044 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4045 if (*p
== '/' || *p
== '\\' || *p
== ':')
4051 strcpy(pbase
, "X$$djren$$.$$temp$$");
4057 *pbase
= try_char
[--idx
];
4058 } while (_chmod(tempfile
, 0) != -1);
4061 _put_path2(tempfile
, olen
);
4063 __dpmi_int(0x21, &r
);
4066 errno
= __doserr_to_errno(r
.x
.ax
);
4070 /* Now create a file with the original name. This will
4071 ensure that NEW will always have a 8+3 alias
4072 different from that of OLD. (Seems to be required
4073 when NameNumericTail in the Registry is set to 0.) */
4074 lfn_fd
= _creat(old
, 0);
4076 olen
= strlen(tempfile
) + 1;
4078 r
.x
.di
= __tb_offset
+ olen
;
4087 _put_path2(new, olen
);
4089 __dpmi_int(0x21, &r
);
4092 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4093 remove(new); /* and try again */
4096 errno
= __doserr_to_errno(r
.x
.ax
);
4098 /* Restore to original name if we renamed it to temporary. */
4106 _put_path2(orig
, olen
);
4107 _put_path(tempfile
);
4109 __dpmi_int(0x21, &r
);
4118 /* Success. Delete the file possibly created to work
4119 around the Windows 95 bug. */
4121 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4125 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4127 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4129 "Return non-nil if long file names are supported on MSDOS.")
4132 return (_USE_LFN
? Qt
: Qnil
);
4135 /* Convert alphabetic characters in a filename to lower-case. */
4138 msdos_downcase_filename (p
)
4139 register unsigned char *p
;
4141 /* Always lower-case drive letters a-z, even if the filesystem
4142 preserves case in filenames.
4143 This is so MSDOS filenames could be compared by string comparison
4144 functions that are case-sensitive. Even case-preserving filesystems
4145 do not distinguish case in drive letters. */
4146 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4152 /* Under LFN we expect to get pathnames in their true case. */
4153 if (NILP (Fmsdos_long_file_names ()))
4155 if (*p
>= 'A' && *p
<= 'Z')
4159 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4161 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4162 When long filenames are supported, doesn't change FILENAME.\n\
4163 If FILENAME is not a string, returns nil.\n\
4164 The argument object is never altered--the value is a copy.")
4166 Lisp_Object filename
;
4170 if (! STRINGP (filename
))
4173 tem
= Fcopy_sequence (filename
);
4174 msdos_downcase_filename (XSTRING (tem
)->data
);
4178 /* The Emacs root directory as determined by init_environment. */
4180 static char emacsroot
[MAXPATHLEN
];
4183 rootrelativepath (rel
)
4186 static char result
[MAXPATHLEN
+ 10];
4188 strcpy (result
, emacsroot
);
4189 strcat (result
, "/");
4190 strcat (result
, rel
);
4194 /* Define a lot of environment variables if not already defined. Don't
4195 remove anything unless you know what you're doing -- lots of code will
4196 break if one or more of these are missing. */
4199 init_environment (argc
, argv
, skip_args
)
4206 static const char * const tempdirs
[] = {
4207 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4210 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4212 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4213 temporary files and assume "/tmp" if $TMPDIR is unset, which
4214 will break on DOS/Windows. Refuse to work if we cannot find
4215 a directory, not even "c:/", usable for that purpose. */
4216 for (i
= 0; i
< imax
; i
++)
4218 const char *tmp
= tempdirs
[i
];
4221 tmp
= getenv (tmp
+ 1);
4222 /* Note that `access' can lie to us if the directory resides on a
4223 read-only filesystem, like CD-ROM or a write-protected floppy.
4224 The only way to be really sure is to actually create a file and
4225 see if it succeeds. But I think that's too much to ask. */
4226 if (tmp
&& access (tmp
, D_OK
) == 0)
4228 setenv ("TMPDIR", tmp
, 1);
4235 Fcons (build_string ("no usable temporary directories found!!"),
4237 "While setting TMPDIR: ");
4239 /* Note the startup time, so we know not to clear the screen if we
4240 exit immediately; see IT_reset_terminal_modes.
4241 (Yes, I know `clock' returns zero the first time it's called, but
4242 I do this anyway, in case some wiseguy changes that at some point.) */
4243 startup_time
= clock ();
4245 /* Find our root from argv[0]. Assuming argv[0] is, say,
4246 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4247 root
= alloca (MAXPATHLEN
+ 20);
4248 _fixpath (argv
[0], root
);
4249 msdos_downcase_filename (root
);
4250 len
= strlen (root
);
4251 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4255 && (strcmp (root
+ len
- 4, "/bin") == 0
4256 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4257 root
[len
- 4] = '\0';
4259 strcpy (root
, "c:/emacs"); /* let's be defensive */
4260 len
= strlen (root
);
4261 strcpy (emacsroot
, root
);
4263 /* We default HOME to our root. */
4264 setenv ("HOME", root
, 0);
4266 /* We default EMACSPATH to root + "/bin". */
4267 strcpy (root
+ len
, "/bin");
4268 setenv ("EMACSPATH", root
, 0);
4270 /* I don't expect anybody to ever use other terminals so the internal
4271 terminal is the default. */
4272 setenv ("TERM", "internal", 0);
4274 #ifdef HAVE_X_WINDOWS
4275 /* Emacs expects DISPLAY to be set. */
4276 setenv ("DISPLAY", "unix:0.0", 0);
4279 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4280 downcase it and mirror the backslashes. */
4281 s
= getenv ("COMSPEC");
4282 if (!s
) s
= "c:/command.com";
4283 t
= alloca (strlen (s
) + 1);
4285 dostounix_filename (t
);
4286 setenv ("SHELL", t
, 0);
4288 /* PATH is also downcased and backslashes mirrored. */
4289 s
= getenv ("PATH");
4291 t
= alloca (strlen (s
) + 3);
4292 /* Current directory is always considered part of MsDos's path but it is
4293 not normally mentioned. Now it is. */
4294 strcat (strcpy (t
, ".;"), s
);
4295 dostounix_filename (t
); /* Not a single file name, but this should work. */
4296 setenv ("PATH", t
, 1);
4298 /* In some sense all dos users have root privileges, so... */
4299 setenv ("USER", "root", 0);
4300 setenv ("NAME", getenv ("USER"), 0);
4302 /* Time zone determined from country code. To make this possible, the
4303 country code may not span more than one time zone. In other words,
4304 in the USA, you lose. */
4306 switch (dos_country_code
)
4308 case 31: /* Belgium */
4309 case 32: /* The Netherlands */
4310 case 33: /* France */
4311 case 34: /* Spain */
4312 case 36: /* Hungary */
4313 case 38: /* Yugoslavia (or what's left of it?) */
4314 case 39: /* Italy */
4315 case 41: /* Switzerland */
4316 case 42: /* Tjekia */
4317 case 45: /* Denmark */
4318 case 46: /* Sweden */
4319 case 47: /* Norway */
4320 case 48: /* Poland */
4321 case 49: /* Germany */
4322 /* Daylight saving from last Sunday in March to last Sunday in
4323 September, both at 2AM. */
4324 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4326 case 44: /* United Kingdom */
4327 case 351: /* Portugal */
4328 case 354: /* Iceland */
4329 setenv ("TZ", "GMT+00", 0);
4331 case 81: /* Japan */
4332 case 82: /* Korea */
4333 setenv ("TZ", "JST-09", 0);
4335 case 90: /* Turkey */
4336 case 358: /* Finland */
4337 setenv ("TZ", "EET-02", 0);
4339 case 972: /* Israel */
4340 /* This is an approximation. (For exact rules, use the
4341 `zoneinfo/israel' file which comes with DJGPP, but you need
4342 to install it in `/usr/share/zoneinfo/' directory first.) */
4343 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4351 static int break_stat
; /* BREAK check mode status. */
4352 static int stdin_stat
; /* stdin IOCTL status. */
4356 /* These must be global. */
4357 static _go32_dpmi_seginfo ctrl_break_vector
;
4358 static _go32_dpmi_registers ctrl_break_regs
;
4359 static int ctrlbreakinstalled
= 0;
4361 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4364 ctrl_break_func (regs
)
4365 _go32_dpmi_registers
*regs
;
4371 install_ctrl_break_check ()
4373 if (!ctrlbreakinstalled
)
4375 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4376 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4377 ctrlbreakinstalled
= 1;
4378 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4379 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4381 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4385 #endif /* __DJGPP__ < 2 */
4387 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4388 control chars by DOS. Determine the keyboard type. */
4393 union REGS inregs
, outregs
;
4394 static int first_time
= 1;
4396 break_stat
= getcbrk ();
4399 install_ctrl_break_check ();
4405 int86 (0x15, &inregs
, &outregs
);
4406 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4410 if (internal_terminal
4411 #ifdef HAVE_X_WINDOWS
4412 && inhibit_window_system
4416 inregs
.x
.ax
= 0x0021;
4417 int86 (0x33, &inregs
, &outregs
);
4418 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4421 /* Reportedly, the above doesn't work for some mouse drivers. There
4422 is an additional detection method that should work, but might be
4423 a little slower. Use that as an alternative. */
4424 inregs
.x
.ax
= 0x0000;
4425 int86 (0x33, &inregs
, &outregs
);
4426 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4431 have_mouse
= 1; /* enable mouse */
4434 if (outregs
.x
.bx
== 3)
4436 mouse_button_count
= 3;
4437 mouse_button_translate
[0] = 0; /* Left */
4438 mouse_button_translate
[1] = 2; /* Middle */
4439 mouse_button_translate
[2] = 1; /* Right */
4443 mouse_button_count
= 2;
4444 mouse_button_translate
[0] = 0;
4445 mouse_button_translate
[1] = 1;
4447 mouse_position_hook
= &mouse_get_pos
;
4451 #ifndef HAVE_X_WINDOWS
4453 /* Save the cursor shape used outside Emacs. */
4454 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4463 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4464 return (stdin_stat
!= -1);
4467 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4469 #else /* __DJGPP__ < 2 */
4473 /* I think it is wrong to overwrite `stdin_stat' every time
4474 but the first one this function is called, but I don't
4475 want to change the way it used to work in v1.x.--EZ */
4477 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4478 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4479 intdos (&inregs
, &outregs
);
4480 stdin_stat
= outregs
.h
.dl
;
4482 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4483 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4484 intdos (&inregs
, &outregs
);
4485 return !outregs
.x
.cflag
;
4487 #endif /* __DJGPP__ < 2 */
4490 /* Restore status of standard input and Ctrl-C checking. */
4495 union REGS inregs
, outregs
;
4497 setcbrk (break_stat
);
4502 #ifndef HAVE_X_WINDOWS
4503 /* Restore the cursor shape we found on startup. */
4507 inregs
.x
.cx
= outside_cursor
;
4508 int86 (0x10, &inregs
, &outregs
);
4512 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4514 #else /* not __DJGPP__ >= 2 */
4516 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4517 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4518 inregs
.x
.dx
= stdin_stat
;
4519 intdos (&inregs
, &outregs
);
4520 return !outregs
.x
.cflag
;
4522 #endif /* not __DJGPP__ >= 2 */
4526 /* Run command as specified by ARGV in directory DIR.
4527 The command is run with input from TEMPIN, output to
4528 file TEMPOUT and stderr to TEMPERR. */
4531 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4532 unsigned char **argv
;
4533 const char *working_dir
;
4534 int tempin
, tempout
, temperr
;
4537 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4538 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4539 int msshell
, result
= -1;
4540 int inbak
, outbak
, errbak
;
4544 /* Get current directory as MSDOS cwd is not per-process. */
4547 /* If argv[0] is the shell, it might come in any lettercase.
4548 Since `Fmember' is case-sensitive, we need to downcase
4549 argv[0], even if we are on case-preserving filesystems. */
4550 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4551 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4554 if (*pl
>= 'A' && *pl
<= 'Z')
4559 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4560 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4561 && !strcmp ("-c", argv
[1]);
4564 saveargv1
= argv
[1];
4565 saveargv2
= argv
[2];
4569 char *p
= alloca (strlen (argv
[2]) + 1);
4571 strcpy (argv
[2] = p
, saveargv2
);
4572 while (*p
&& isspace (*p
))
4574 while (*p
&& !isspace (*p
))
4582 chdir (working_dir
);
4586 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4587 goto done
; /* Allocation might fail due to lack of descriptors. */
4590 mouse_get_xy (&x
, &y
);
4592 dos_ttcooked (); /* do it here while 0 = stdin */
4600 if (msshell
&& !argv
[3])
4602 /* MS-DOS native shells are too restrictive. For starters, they
4603 cannot grok commands longer than 126 characters. In DJGPP v2
4604 and later, `system' is much smarter, so we'll call it instead. */
4608 /* A shell gets a single argument--its full command
4609 line--whose original was saved in `saveargv2'. */
4611 /* Don't let them pass empty command lines to `system', since
4612 with some shells it will try to invoke an interactive shell,
4613 which will hang Emacs. */
4614 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4618 extern char **environ
;
4619 int save_system_flags
= __system_flags
;
4621 /* Request the most powerful version of `system'. We need
4622 all the help we can get to avoid calling stock DOS shells. */
4623 __system_flags
= (__system_redirect
4624 | __system_use_shell
4625 | __system_allow_multiple_cmds
4626 | __system_allow_long_cmds
4627 | __system_handle_null_commands
4628 | __system_emulate_chdir
);
4631 result
= system (cmnd
);
4632 __system_flags
= save_system_flags
;
4635 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4639 #endif /* __DJGPP__ > 1 */
4641 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4646 emacs_close (inbak
);
4647 emacs_close (outbak
);
4648 emacs_close (errbak
);
4654 mouse_moveto (x
, y
);
4657 /* Some programs might change the meaning of the highest bit of the
4658 text attribute byte, so we get blinking characters instead of the
4659 bright background colors. Restore that. */
4666 argv
[1] = saveargv1
;
4667 argv
[2] = saveargv2
;
4675 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4682 /* ------------------------- Compatibility functions -------------------
4687 /* Hostnames for a pc are not really funny,
4688 but they are used in change log so we emulate the best we can. */
4690 gethostname (p
, size
)
4694 char *q
= egetenv ("HOSTNAME");
4701 /* When time zones are set from Ms-Dos too many C-libraries are playing
4702 tricks with time values. We solve this by defining our own version
4703 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4704 once and after each call to `tzset' with TZ changed. That is
4705 accomplished by aliasing tzset to init_gettimeofday. */
4707 static struct tm time_rec
;
4710 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4718 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4722 time_rec
.tm_year
= d
.da_year
- 1900;
4723 time_rec
.tm_mon
= d
.da_mon
- 1;
4724 time_rec
.tm_mday
= d
.da_day
;
4727 time_rec
.tm_hour
= t
.ti_hour
;
4728 time_rec
.tm_min
= t
.ti_min
;
4729 time_rec
.tm_sec
= t
.ti_sec
;
4732 tm
.tm_gmtoff
= dos_timezone_offset
;
4734 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4735 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4737 /* Ignore tzp; it's obsolescent. */
4741 #endif /* __DJGPP__ < 2 */
4744 * A list of unimplemented functions that we silently ignore.
4748 unsigned alarm (s
) unsigned s
; {}
4749 fork () { return 0; }
4750 int kill (x
, y
) int x
, y
; { return -1; }
4752 void volatile pause () {}
4753 sigsetmask (x
) int x
; { return 0; }
4754 sigblock (mask
) int mask
; { return 0; }
4757 void request_sigio (void) {}
4758 setpgrp () {return 0; }
4759 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4760 void unrequest_sigio (void) {}
4764 #ifdef POSIX_SIGNALS
4766 /* Augment DJGPP library POSIX signal functions. This is needed
4767 as of DJGPP v2.01, but might be in the library in later releases. */
4769 #include <libc/bss.h>
4771 /* A counter to know when to re-initialize the static sets. */
4772 static int sigprocmask_count
= -1;
4774 /* Which signals are currently blocked (initially none). */
4775 static sigset_t current_mask
;
4777 /* Which signals are pending (initially none). */
4778 static sigset_t pending_signals
;
4780 /* Previous handlers to restore when the blocked signals are unblocked. */
4781 typedef void (*sighandler_t
)(int);
4782 static sighandler_t prev_handlers
[320];
4784 /* A signal handler which just records that a signal occured
4785 (it will be raised later, if and when the signal is unblocked). */
4787 sig_suspender (signo
)
4790 sigaddset (&pending_signals
, signo
);
4794 sigprocmask (how
, new_set
, old_set
)
4796 const sigset_t
*new_set
;
4802 /* If called for the first time, initialize. */
4803 if (sigprocmask_count
!= __bss_count
)
4805 sigprocmask_count
= __bss_count
;
4806 sigemptyset (&pending_signals
);
4807 sigemptyset (¤t_mask
);
4808 for (signo
= 0; signo
< 320; signo
++)
4809 prev_handlers
[signo
] = SIG_ERR
;
4813 *old_set
= current_mask
;
4818 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4824 sigemptyset (&new_mask
);
4826 /* DJGPP supports upto 320 signals. */
4827 for (signo
= 0; signo
< 320; signo
++)
4829 if (sigismember (¤t_mask
, signo
))
4830 sigaddset (&new_mask
, signo
);
4831 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4833 sigaddset (&new_mask
, signo
);
4835 /* SIGKILL is silently ignored, as on other platforms. */
4836 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4837 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
4839 if (( how
== SIG_UNBLOCK
4840 && sigismember (&new_mask
, signo
)
4841 && sigismember (new_set
, signo
))
4842 || (how
== SIG_SETMASK
4843 && sigismember (&new_mask
, signo
)
4844 && !sigismember (new_set
, signo
)))
4846 sigdelset (&new_mask
, signo
);
4847 if (prev_handlers
[signo
] != SIG_ERR
)
4849 signal (signo
, prev_handlers
[signo
]);
4850 prev_handlers
[signo
] = SIG_ERR
;
4852 if (sigismember (&pending_signals
, signo
))
4854 sigdelset (&pending_signals
, signo
);
4859 current_mask
= new_mask
;
4863 #else /* not POSIX_SIGNALS */
4865 sigsetmask (x
) int x
; { return 0; }
4866 sigblock (mask
) int mask
; { return 0; }
4868 #endif /* not POSIX_SIGNALS */
4869 #endif /* __DJGPP__ > 1 */
4872 #include "sysselect.h"
4874 #ifndef EMACS_TIME_ZERO_OR_NEG_P
4875 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
4876 ((long)(time).tv_sec < 0 \
4877 || ((time).tv_sec == 0 \
4878 && (long)(time).tv_usec <= 0))
4881 /* This yields the rest of the current time slice to the task manager.
4882 It should be called by any code which knows that it has nothing
4883 useful to do except idle.
4885 I don't use __dpmi_yield here, since versions of library before 2.02
4886 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
4887 on some versions of Windows 9X. */
4890 dos_yield_time_slice (void)
4892 _go32_dpmi_registers r
;
4895 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
4896 _go32_dpmi_simulate_int (0x2f, &r
);
4901 /* Only event queue is checked. */
4902 /* We don't have to call timer_check here
4903 because wait_reading_process_input takes care of that. */
4905 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
4907 SELECT_TYPE
*rfds
, *wfds
, *efds
;
4908 EMACS_TIME
*timeout
;
4916 check_input
= FD_ISSET (0, rfds
);
4927 /* If we are looking only for the terminal, with no timeout,
4928 just read it and wait -- that's more efficient. */
4931 while (!detect_input_pending ())
4933 dos_yield_time_slice ();
4938 EMACS_TIME clnow
, cllast
, cldiff
;
4941 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
4943 while (!check_input
|| !detect_input_pending ())
4946 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
4947 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
4949 /* When seconds wrap around, we assume that no more than
4950 1 minute passed since last `gettime'. */
4951 if (EMACS_TIME_NEG_P (cldiff
))
4952 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
4953 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
4955 /* Stop when timeout value crosses zero. */
4956 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
4959 dos_yield_time_slice ();
4969 * Define overlaid functions:
4971 * chdir -> sys_chdir
4972 * tzset -> init_gettimeofday
4973 * abort -> dos_abort
4978 extern int chdir ();
4984 int len
= strlen (path
);
4985 char *tmp
= (char *)path
;
4987 if (*tmp
&& tmp
[1] == ':')
4989 if (getdisk () != tolower (tmp
[0]) - 'a')
4990 setdisk (tolower (tmp
[0]) - 'a');
4991 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
4995 if (len
> 1 && (tmp
[len
- 1] == '/'))
4997 char *tmp1
= (char *) alloca (len
+ 1);
5008 extern void tzset (void);
5011 init_gettimeofday ()
5017 ltm
= gtm
= time (NULL
);
5018 ltm
= mktime (lstm
= localtime (<m
));
5019 gtm
= mktime (gmtime (>m
));
5020 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5021 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5022 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5029 dos_abort (file
, line
)
5033 char buffer1
[200], buffer2
[400];
5036 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5037 for (i
= j
= 0; buffer1
[i
]; i
++) {
5038 buffer2
[j
++] = buffer1
[i
];
5039 buffer2
[j
++] = 0x70;
5041 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5042 ScreenSetCursor (2, 0);
5050 ScreenSetCursor (10, 0);
5051 cputs ("\r\n\nEmacs aborted!\r\n");
5053 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5054 if (screen_virtual_segment
)
5055 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5056 /* Generate traceback, so we could tell whodunit. */
5057 signal (SIGINT
, SIG_DFL
);
5058 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5059 #else /* __DJGPP_MINOR__ >= 2 */
5061 #endif /* __DJGPP_MINOR__ >= 2 */
5067 /* The following variables are required so that cus-start.el won't
5068 complain about unbound variables. */
5069 #ifndef HAVE_X_WINDOWS
5070 /* Search path for bitmap files (xfns.c). */
5071 Lisp_Object Vx_bitmap_file_path
;
5072 int x_stretch_cursor_p
;
5074 #ifndef subprocesses
5075 /* Nonzero means delete a process right away if it exits (process.c). */
5076 static int delete_exited_processes
;
5081 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5082 staticpro (&recent_doskeys
);
5083 #ifndef HAVE_X_WINDOWS
5084 staticpro (&help_echo
);
5086 staticpro (&previous_help_echo
);
5087 previous_help_echo
= Qnil
;
5089 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5090 "List of directories to search for bitmap files for X.");
5091 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5093 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5094 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5095 For example, if a block cursor is over a tab, it will be drawn as\n\
5096 wide as that tab on the display. (No effect on MS-DOS.)");
5097 x_stretch_cursor_p
= 0;
5099 /* The following three are from xfns.c: */
5100 Qbackground_color
= intern ("background-color");
5101 staticpro (&Qbackground_color
);
5102 Qforeground_color
= intern ("foreground-color");
5103 staticpro (&Qforeground_color
);
5104 Qbar
= intern ("bar");
5106 Qcursor_type
= intern ("cursor-type");
5107 staticpro (&Qcursor_type
);
5108 Qreverse
= intern ("reverse");
5109 staticpro (&Qreverse
);
5111 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5112 "*Glyph to display instead of chars not supported by current codepage.\n\
5114 This variable is used only by MSDOS terminals.");
5115 Vdos_unsupported_char_glyph
= '\177';
5117 #ifndef subprocesses
5118 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5119 "*Non-nil means delete processes immediately when they exit.\n\
5120 nil means don't delete them until `list-processes' is run.");
5121 delete_exited_processes
= 0;
5124 defsubr (&Srecent_doskeys
);
5125 defsubr (&Smsdos_long_file_names
);
5126 defsubr (&Smsdos_downcase_filename
);
5127 defsubr (&Smsdos_remember_default_colors
);