-/* MS-DOS specific C utilities.
- Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+/* MS-DOS specific C utilities. -*- coding: raw-text -*-
+ Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "lisp.h"
#include <stdio.h>
#include <stdlib.h>
+#include <time.h>
#include <sys/param.h>
#include <sys/time.h>
#include <dos.h>
+#include <errno.h>
+#include <string.h> /* for bzero and string functions */
+#include <sys/stat.h> /* for _fixpath */
+#include <unistd.h> /* for chdir, dup, dup2, etc. */
#if __DJGPP__ >= 2
#include <fcntl.h>
+#include <io.h> /* for setmode */
+#include <dpmi.h> /* for __dpmi_xxx stuff */
+#include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
+#include <libc/dosio.h> /* for _USE_LFN */
+#include <conio.h> /* for cputs */
#endif
-#include "dosfns.h"
#include "msdos.h"
#include "systime.h"
#include "termhooks.h"
+#include "termchar.h"
#include "dispextern.h"
+#include "dosfns.h"
#include "termopts.h"
+#include "charset.h"
+#include "coding.h"
+#include "disptab.h"
#include "frame.h"
#include "window.h"
+#include "buffer.h"
+#include "commands.h"
#include <go32.h>
#include <pc.h>
#include <ctype.h>
/* Damn that local process.h! Instead we can define P_WAIT ourselves. */
#define P_WAIT 1
+#ifndef _USE_LFN
+#define _USE_LFN 0
+#endif
+
+#ifndef _dos_ds
+#define _dos_ds _go32_info_block.selector_for_linear_memory
+#endif
+
#if __DJGPP__ > 1
#include <signal.h>
+#include "syssignal.h"
#ifndef SYSTEM_MALLOC
}
}
+static void
+mouse_get_xy (int *x, int *y)
+{
+ union REGS regs;
+
+ regs.x.ax = 0x0003;
+ int86 (0x33, ®s, ®s);
+ *x = regs.x.cx / 8;
+ *y = regs.x.dx / 8;
+}
+
void
mouse_moveto (x, y)
int x, y;
return (regs.x.bx != 0);
}
-static void
-mouse_get_xy (int *x, int *y)
+static int
+mouse_button_depressed (b, xp, yp)
+ int b, *xp, *yp;
{
union REGS regs;
+ if (b >= mouse_button_count)
+ return 0;
regs.x.ax = 0x0003;
int86 (0x33, ®s, ®s);
- *x = regs.x.cx / 8;
- *y = regs.x.dx / 8;
+ if ((regs.x.bx & (1 << mouse_button_translate[b])) != 0)
+ {
+ *xp = regs.x.cx / 8;
+ *yp = regs.x.dx / 8;
+ return 1;
+ }
+ return 0;
}
void
unsigned long *time;
{
int ix, iy;
- union REGS regs;
+ Lisp_Object frame, tail;
- regs.x.ax = 0x0003;
- int86 (0x33, ®s, ®s);
- *f = selected_frame;
+ /* Clear the mouse-moved flag for every frame on this display. */
+ FOR_EACH_FRAME (tail, frame)
+ XFRAME (frame)->mouse_moved = 0;
+
+ *f = SELECTED_FRAME();
*bar_window = Qnil;
mouse_get_xy (&ix, &iy);
- selected_frame->mouse_moved = 0;
- *x = make_number (ix);
- *y = make_number (iy);
*time = event_timestamp ();
+ *x = make_number (mouse_last_x = ix);
+ *y = make_number (mouse_last_y = iy);
}
static void
int x, y;
mouse_get_xy (&x, &y);
- selected_frame->mouse_moved |= (x != mouse_last_x || y != mouse_last_y);
+ SELECTED_FRAME()->mouse_moved |= (x != mouse_last_x || y != mouse_last_y);
mouse_last_x = x;
mouse_last_y = y;
}
mouse_init ()
{
union REGS regs;
+ int b;
if (termscript)
fprintf (termscript, "<M_INIT>");
regs.x.ax = 0x0021;
int86 (0x33, ®s, ®s);
+ /* Reset the mouse last press/release info. It seems that Windows
+ doesn't do that automatically when function 21h is called, which
+ causes Emacs to ``remember'' the click that switched focus to the
+ window just before Emacs was started from that window. */
+ for (b = 0; b < mouse_button_count; b++)
+ {
+ int dummy_x, dummy_y;
+
+ (void) mouse_pressed (b, &dummy_x, &dummy_y);
+ (void) mouse_released (b, &dummy_x, &dummy_y);
+ }
+
regs.x.ax = 0x0007;
regs.x.cx = 0;
regs.x.dx = 8 * (ScreenCols () - 1);
static int startup_pos_Y;
static unsigned char startup_screen_attrib;
+static clock_t startup_time;
+
static int term_setup_done;
/* Similar to the_only_frame. */
struct x_output the_only_x_display;
-/* This is never dereferenced. */
-Display *x_current_display;
+/* Support for DOS/V (allows Japanese characters to be displayed on
+ standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
+
+/* Holds the address of the text-mode screen buffer. */
+static unsigned long screen_old_address = 0;
+/* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
+static unsigned short screen_virtual_segment = 0;
+static unsigned short screen_virtual_offset = 0;
+/* A flag to control how to display unibyte 8-bit characters. */
+extern int unibyte_display_via_language_environment;
+
+#if __DJGPP__ > 1
+/* Update the screen from a part of relocated DOS/V screen buffer which
+ begins at OFFSET and includes COUNT characters. */
+static void
+dosv_refresh_virtual_screen (int offset, int count)
+{
+ __dpmi_regs regs;
+ if (offset < 0 || count < 0) /* paranoia; illegal values crash DOS/V */
+ return;
-#define SCREEN_SET_CURSOR() \
- if (current_pos_X != new_pos_X || current_pos_Y != new_pos_Y) \
- ScreenSetCursor (current_pos_Y = new_pos_Y, current_pos_X = new_pos_X)
+ regs.h.ah = 0xff; /* update relocated screen */
+ regs.x.es = screen_virtual_segment;
+ regs.x.di = screen_virtual_offset + offset;
+ regs.x.cx = count;
+ __dpmi_int (0x10, ®s);
+}
+#endif
-static
+static void
dos_direct_output (y, x, buf, len)
int y;
int x;
char *buf;
int len;
{
- int t = (int) ScreenPrimary + 2 * (x + y * screen_size_X);
-
+ int t0 = 2 * (x + y * screen_size_X);
+ int t = t0 + (int) ScreenPrimary;
+ int l0 = len;
+
+#if (__DJGPP__ < 2)
while (--len >= 0) {
dosmemput (buf++, 1, t);
t += 2;
}
+#else
+ /* This is faster. */
+ for (_farsetsel (_dos_ds); --len >= 0; t += 2, buf++)
+ _farnspokeb (t, *buf);
+
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (t0, l0);
+#endif
}
#endif
#ifndef HAVE_X_WINDOWS
+static int blink_bit = -1; /* the state of the blink bit at startup */
+
+/* Enable bright background colors. */
+static void
+bright_bg (void)
+{
+ union REGS regs;
+
+ /* Remember the original state of the blink/bright-background bit.
+ It is stored at 0040:0065h in the BIOS data area. */
+ if (blink_bit == -1)
+ blink_bit = (_farpeekb (_dos_ds, 0x465) & 0x20) == 0x20;
+
+ regs.h.bl = 0;
+ regs.x.ax = 0x1003;
+ int86 (0x10, ®s, ®s);
+}
+
+/* Disable bright background colors (and enable blinking) if we found
+ the video system in that state at startup. */
+static void
+maybe_enable_blinking (void)
+{
+ if (blink_bit == 1)
+ {
+ union REGS regs;
+
+ regs.h.bl = 1;
+ regs.x.ax = 0x1003;
+ int86 (0x10, ®s, ®s);
+ }
+}
+
/* Set the screen dimensions so that it can show no less than
ROWS x COLS frame. */
{
regs.x.ax = video_mode_value;
int86 (0x10, ®s, ®s);
- regs.h.bl = 0;
- regs.x.ax = 0x1003;
- int86 (0x10, ®s, ®s);
if (have_mouse)
{
/* Tell the caller what dimensions have been REALLY set. */
*rows = ScreenRows ();
*cols = ScreenCols ();
+
+ /* Enable bright background colors. */
+ bright_bg ();
+
+ /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
+ be defensive anyway. */
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (0, *cols * *rows);
}
/* If we write a character in the position where the mouse is,
mouse_off ();
}
-static
-IT_ring_bell ()
+static void
+IT_ring_bell (void)
{
if (visible_bell)
{
}
}
+/* Given a face id FACE, extract the face parameters to be used for
+ display until the face changes. The face parameters (actually, its
+ color) are used to construct the video attribute byte for each
+ glyph during the construction of the buffer that is then blitted to
+ the video RAM. */
static void
IT_set_face (int face)
{
- struct face *fp;
- extern struct face *intern_face (/* FRAME_PTR, struct face * */);
+ struct frame *sf = SELECTED_FRAME();
+ struct face *fp = FACE_FROM_ID (sf, face);
+ unsigned long fg, bg;
- if (face == 1 || (face == 0 && highlight))
- fp = FRAME_MODE_LINE_FACE (foo);
- else if (face <= 0 || face >= FRAME_N_COMPUTED_FACES (foo))
- fp = FRAME_DEFAULT_FACE (foo);
- else
- fp = intern_face (selected_frame, FRAME_COMPUTED_FACES (foo)[face]);
- if (termscript)
- fprintf (termscript, "<FACE:%d:%d>", FACE_FOREGROUND (fp), FACE_BACKGROUND (fp));
+ if (!fp)
+ {
+ fp = FACE_FROM_ID (sf, DEFAULT_FACE_ID);
+ /* The default face for the frame should always be realized and
+ cached. */
+ if (!fp)
+ abort ();
+ }
screen_face = face;
- ScreenAttrib = (FACE_BACKGROUND (fp) << 4) | FACE_FOREGROUND (fp);
+ fg = fp->foreground;
+ bg = fp->background;
+
+ /* Don't use invalid colors. In particular, a color of -1 means use
+ the colors of the default face, except that if highlight is on,
+ invert the foreground and the background. Note that we assume
+ all 16 colors to be available for the background, since Emacs
+ switches on this mode (and loses the blinking attribute) at
+ startup. */
+ if (fg == (unsigned long)-1)
+ fg = highlight || fp->tty_reverse_p ? FRAME_BACKGROUND_PIXEL (sf)
+ : FRAME_FOREGROUND_PIXEL (sf);
+ if (bg == (unsigned long)-1)
+ bg = highlight || fp->tty_reverse_p ? FRAME_FOREGROUND_PIXEL (sf)
+ : FRAME_BACKGROUND_PIXEL (sf);
+ if (termscript)
+ fprintf (termscript, "<FACE %d%s: %d/%d>",
+ face, highlight ? "H" : "", fp->foreground, fp->background);
+ if (fg >= 0 && fg < 16)
+ {
+ ScreenAttrib &= 0xf0;
+ ScreenAttrib |= fg;
+ }
+ if (bg >= 0 && bg < 16)
+ {
+ ScreenAttrib &= 0x0f;
+ ScreenAttrib |= ((bg & 0x0f) << 4);
+ }
}
-static
-IT_write_glyphs (GLYPH *str, int len)
-{
- int newface;
- int ch, l = len;
- unsigned char *buf, *bp;
+Lisp_Object Vdos_unsupported_char_glyph;
- if (len == 0) return;
+static void
+IT_write_glyphs (struct glyph *str, int str_len)
+{
+ unsigned char *screen_buf, *screen_bp, *screen_buf_end, *bp;
+ int unsupported_face = FAST_GLYPH_FACE (Vdos_unsupported_char_glyph);
+ unsigned unsupported_char= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph);
+ int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
+ register int sl = str_len;
+ register int tlen = GLYPH_TABLE_LENGTH;
+ register Lisp_Object *tbase = GLYPH_TABLE_BASE;
+
+ struct coding_system *coding = (CODING_REQUIRE_ENCODING (&terminal_coding)
+ ? &terminal_coding
+ : &safe_terminal_coding);
+ struct frame *sf;
+
+ /* Do we need to consider conversion of unibyte characters to
+ multibyte? */
+ int convert_unibyte_characters
+ = (NILP (current_buffer->enable_multibyte_characters)
+ && unibyte_display_via_language_environment);
+
+ if (str_len == 0) return;
- buf = bp = alloca (len * 2);
+ screen_buf = screen_bp = alloca (str_len * 2);
+ screen_buf_end = screen_buf + str_len * 2;
+ sf = SELECTED_FRAME();
+
+ /* Since faces get cached and uncached behind our back, we can't
+ rely on their indices in the cache being consistent across
+ invocations. So always reset the screen face to the default
+ face of the frame, before writing glyphs, and let the glyphs
+ set the right face if it's different from the default. */
+ IT_set_face (DEFAULT_FACE_ID);
- while (--l >= 0)
- {
- newface = FAST_GLYPH_FACE (*str);
- if (newface != screen_face)
- IT_set_face (newface);
- ch = FAST_GLYPH_CHAR (*str);
- *bp++ = (unsigned char)ch;
- *bp++ = ScreenAttrib;
-
- if (termscript)
- fputc (ch, termscript);
- str++;
+ /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
+ the tail. */
+ terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+ while (sl)
+ {
+ int cf, chlen, enclen;
+ unsigned char workbuf[4], *buf;
+ unsigned ch;
+ register GLYPH g = GLYPH_FROM_CHAR_GLYPH (*str);
+
+ /* Find the actual glyph to display by traversing the entire
+ aliases chain for this glyph. */
+ GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
+
+ /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
+ only for the redisplay code to know how many columns does
+ this character occupy on the screen. Skip padding glyphs. */
+ if (CHAR_GLYPH_PADDING_P (*str))
+ {
+ str++;
+ sl--;
+ }
+ else
+ {
+ /* Convert the character code to multibyte, if they
+ requested display via language environment. */
+ ch = FAST_GLYPH_CHAR (g);
+ /* We only want to convert unibyte characters to multibyte
+ in unibyte buffers! Otherwise, the 8-bit code might come
+ from the display table set up to display foreign characters. */
+ if (SINGLE_BYTE_CHAR_P (ch) && convert_unibyte_characters
+ && (ch >= 0240
+ || (ch >= 0200 && !NILP (Vnonascii_translation_table))))
+ ch = unibyte_char_to_multibyte (ch);
+
+ /* Invalid characters are displayed with a special glyph. */
+ if (! GLYPH_CHAR_VALID_P (ch))
+ {
+ g = !NILP (Vdos_unsupported_char_glyph)
+ ? Vdos_unsupported_char_glyph
+ : MAKE_GLYPH (sf, '\177', GLYPH_FACE (sf, g));
+ ch = FAST_GLYPH_CHAR (g);
+ }
+ if (COMPOSITE_CHAR_P (ch))
+ {
+ /* If CH is a composite character, we can display
+ only the first component. */
+ g = cmpchar_table[COMPOSITE_CHAR_ID (ch)]->glyph[0],
+ ch = GLYPH_CHAR (sf, g);
+ cf = FAST_GLYPH_FACE (g);
+ }
+
+ /* If the face of this glyph is different from the current
+ screen face, update the screen attribute byte. */
+ cf = FAST_GLYPH_FACE (g);
+ if (cf != screen_face)
+ IT_set_face (cf); /* handles invalid faces gracefully */
+
+ if (GLYPH_SIMPLE_P (tbase, tlen, g))
+ /* We generate the multi-byte form of CH in BUF. */
+ chlen = CHAR_STRING (ch, workbuf, buf);
+ else
+ {
+ /* We have a string in Vglyph_table. */
+ chlen = GLYPH_LENGTH (tbase, g);
+ buf = GLYPH_STRING (tbase, g);
+ }
+
+ /* If the character is not multibyte, don't bother converting it. */
+ if (chlen == 1)
+ {
+ *conversion_buffer = (unsigned char)ch;
+ chlen = 0;
+ enclen = 1;
+ }
+ else
+ {
+ encode_coding (coding, buf, conversion_buffer, chlen,
+ conversion_buffer_size);
+ chlen -= coding->consumed;
+ enclen = coding->produced;
+
+ /* Replace glyph codes that cannot be converted by
+ terminal_coding with Vdos_unsupported_char_glyph. */
+ if (*conversion_buffer == '?')
+ {
+ char *cbp = conversion_buffer;
+
+ while (cbp < conversion_buffer + enclen && *cbp == '?')
+ *cbp++ = unsupported_char;
+ if (unsupported_face != screen_face)
+ IT_set_face (unsupported_face);
+ }
+ }
+
+ if (enclen + chlen > screen_buf_end - screen_bp)
+ {
+ /* The allocated buffer for screen writes is too small.
+ Flush it and loop again without incrementing STR, so
+ that the next loop will begin with the same glyph. */
+ int nbytes = screen_bp - screen_buf;
+
+ mouse_off_maybe ();
+ dosmemput (screen_buf, nbytes, (int)ScreenPrimary + offset);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (offset, nbytes / 2);
+ new_pos_X += nbytes / 2;
+ offset += nbytes;
+
+ /* Prepare to reuse the same buffer again. */
+ screen_bp = screen_buf;
+ }
+ else
+ {
+ /* There's enough place in the allocated buffer to add
+ the encoding of this glyph. */
+
+ /* First, copy the encoded bytes. */
+ for (bp = conversion_buffer; enclen--; bp++)
+ {
+ *screen_bp++ = (unsigned char)*bp;
+ *screen_bp++ = ScreenAttrib;
+ if (termscript)
+ fputc (*bp, termscript);
+ }
+
+ /* Now copy the bytes not consumed by the encoding. */
+ if (chlen > 0)
+ {
+ buf += coding->consumed;
+ while (chlen--)
+ {
+ if (termscript)
+ fputc (*buf, termscript);
+ *screen_bp++ = (unsigned char)*buf++;
+ *screen_bp++ = ScreenAttrib;
+ }
+ }
+
+ /* Update STR and its remaining length. */
+ str++;
+ sl--;
+ }
+ }
}
+ /* Dump whatever is left in the screen buffer. */
mouse_off_maybe ();
- dosmemput (buf, 2 * len,
- (int)ScreenPrimary + 2 * (new_pos_X + screen_size_X * new_pos_Y));
- new_pos_X += len;
+ dosmemput (screen_buf, screen_bp - screen_buf, (int)ScreenPrimary + offset);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (offset, (screen_bp - screen_buf) / 2);
+ new_pos_X += (screen_bp - screen_buf) / 2;
+
+ /* We may have to output some codes to terminate the writing. */
+ if (CODING_REQUIRE_FLUSHING (coding))
+ {
+ coding->mode |= CODING_MODE_LAST_BLOCK;
+ encode_coding (coding, "", conversion_buffer, 0, conversion_buffer_size);
+ if (coding->produced > 0)
+ {
+ for (screen_bp = screen_buf, bp = conversion_buffer;
+ coding->produced--; bp++)
+ {
+ *screen_bp++ = (unsigned char)*bp;
+ *screen_bp++ = ScreenAttrib;
+ if (termscript)
+ fputc (*bp, termscript);
+ }
+ offset += screen_bp - screen_buf;
+ mouse_off_maybe ();
+ dosmemput (screen_buf, screen_bp - screen_buf,
+ (int)ScreenPrimary + offset);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (offset, (screen_bp - screen_buf) / 2);
+ new_pos_X += (screen_bp - screen_buf) / 2;
+ }
+ }
}
-static
-IT_clear_end_of_line (first_unused)
+static void
+IT_clear_end_of_line (int first_unused)
{
char *spaces, *sp;
int i, j;
+ int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
+ extern int fatal_error_in_progress;
+
+ if (new_pos_X >= first_unused || fatal_error_in_progress)
+ return;
IT_set_face (0);
if (termscript)
fprintf (termscript, "<CLR:EOL>");
- i = (j = screen_size_X - new_pos_X) * 2;
+ i = (j = first_unused - new_pos_X) * 2;
spaces = sp = alloca (i);
while (--j >= 0)
}
mouse_off_maybe ();
- dosmemput (spaces, i,
- (int)ScreenPrimary + 2 * (new_pos_X + screen_size_X * new_pos_Y));
+ dosmemput (spaces, i, (int)ScreenPrimary + offset);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (offset, i / 2);
+
+ /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
+ Let's follow their lead, in case someone relies on this. */
+ new_pos_X = first_unused;
}
-static
+static void
IT_clear_screen (void)
{
if (termscript)
IT_set_face (0);
mouse_off ();
ScreenClear ();
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (0, screen_size);
new_pos_X = new_pos_Y = 0;
}
-static
+static void
IT_clear_to_end (void)
{
if (termscript)
}
}
-static
+static void
IT_cursor_to (int y, int x)
{
if (termscript)
new_pos_Y = y;
}
-static
-IT_reassert_line_highlight (new, vpos)
- int new, vpos;
+static int cursor_cleared;
+
+static void
+IT_display_cursor (int on)
+{
+ if (on && cursor_cleared)
+ {
+ ScreenSetCursor (current_pos_Y, current_pos_X);
+ cursor_cleared = 0;
+ }
+ else if (!on && !cursor_cleared)
+ {
+ ScreenSetCursor (-1, -1);
+ cursor_cleared = 1;
+ }
+}
+
+/* Emacs calls cursor-movement functions a lot when it updates the
+ display (probably a legacy of old terminals where you cannot
+ update a screen line without first moving the cursor there).
+ However, cursor movement is expensive on MSDOS (it calls a slow
+ BIOS function and requires 2 mode switches), while actual screen
+ updates access the video memory directly and don't depend on
+ cursor position. To avoid slowing down the redisplay, we cheat:
+ all functions that move the cursor only set internal variables
+ which record the cursor position, whereas the cursor is only
+ moved to its final position whenever screen update is complete.
+
+ `IT_cmgoto' is called from the keyboard reading loop and when the
+ frame update is complete. This means that we are ready for user
+ input, so we update the cursor position to show where the point is,
+ and also make the mouse pointer visible.
+
+ Special treatment is required when the cursor is in the echo area,
+ to put the cursor at the end of the text displayed there. */
+
+static void
+IT_cmgoto (FRAME_PTR f)
+{
+ /* Only set the cursor to where it should be if the display is
+ already in sync with the window contents. */
+ int update_cursor_pos = 1; /* MODIFF == unchanged_modified; */
+
+ /* FIXME: This needs to be rewritten for the new redisplay, or
+ removed. */
+#if 0
+ static int previous_pos_X = -1;
+
+ update_cursor_pos = 1; /* temporary!!! */
+
+ /* If the display is in sync, forget any previous knowledge about
+ cursor position. This is primarily for unexpected events like
+ C-g in the minibuffer. */
+ if (update_cursor_pos && previous_pos_X >= 0)
+ previous_pos_X = -1;
+ /* If we are in the echo area, put the cursor at the
+ end of the echo area message. */
+ if (!update_cursor_pos
+ && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top) <= new_pos_Y)
+ {
+ int tem_X = current_pos_X, dummy;
+
+ if (echo_area_glyphs)
+ {
+ tem_X = echo_area_glyphs_length;
+ /* Save current cursor position, to be restored after the
+ echo area message is erased. Only remember one level
+ of previous cursor position. */
+ if (previous_pos_X == -1)
+ ScreenGetCursor (&dummy, &previous_pos_X);
+ }
+ else if (previous_pos_X >= 0)
+ {
+ /* We wind up here after the echo area message is erased.
+ Restore the cursor position we remembered above. */
+ tem_X = previous_pos_X;
+ previous_pos_X = -1;
+ }
+
+ if (current_pos_X != tem_X)
+ {
+ new_pos_X = tem_X;
+ update_cursor_pos = 1;
+ }
+ }
+#endif
+
+ if (update_cursor_pos
+ && (current_pos_X != new_pos_X || current_pos_Y != new_pos_Y))
+ {
+ ScreenSetCursor (current_pos_Y = new_pos_Y, current_pos_X = new_pos_X);
+ if (termscript)
+ fprintf (termscript, "\n<CURSOR:%dx%d>", current_pos_X, current_pos_Y);
+ }
+
+ /* Maybe cursor is invisible, so make it visible. */
+ IT_display_cursor (1);
+
+ /* Mouse pointer should be always visible if we are waiting for
+ keyboard input. */
+ if (!mouse_visible)
+ mouse_on ();
+}
+
+static void
+IT_reassert_line_highlight (int new, int vpos)
{
highlight = new;
- IT_set_face (0); /* To possibly clear the highlighting. */
}
-static
-IT_change_line_highlight (new_highlight, vpos, first_unused_hpos)
+static void
+IT_change_line_highlight (int new_highlight, int y, int vpos, int first_unused_hpos)
{
highlight = new_highlight;
- IT_set_face (0); /* To possibly clear the highlighting. */
IT_cursor_to (vpos, 0);
IT_clear_end_of_line (first_unused_hpos);
}
-static
-IT_update_begin ()
+static void
+IT_update_begin (struct frame *foo)
{
highlight = 0;
- IT_set_face (0); /* To possibly clear the highlighting. */
- screen_face = -1;
}
-static
-IT_update_end ()
+static void
+IT_update_end (struct frame *foo)
{
}
-/* This was more or less copied from xterm.c */
-
+/* Copy LEN glyphs displayed on a single line whose vertical position
+ is YPOS, beginning at horizontal position XFROM to horizontal
+ position XTO, by moving blocks in the video memory. Used by
+ functions that insert and delete glyphs. */
static void
-IT_set_menu_bar_lines (window, n)
- Lisp_Object window;
- int n;
+IT_copy_glyphs (int xfrom, int xto, size_t len, int ypos)
{
- struct window *w = XWINDOW (window);
+ /* The offsets of source and destination relative to the
+ conventional memorty selector. */
+ int from = 2 * (xfrom + screen_size_X * ypos) + ScreenPrimary;
+ int to = 2 * (xto + screen_size_X * ypos) + ScreenPrimary;
- XSETFASTINT (w->last_modified, 0);
- XSETFASTINT (w->top, XFASTINT (w->top) + n);
- XSETFASTINT (w->height, XFASTINT (w->height) - n);
+ if (from == to || len <= 0)
+ return;
- /* Handle just the top child in a vertical split. */
- if (!NILP (w->vchild))
- IT_set_menu_bar_lines (w->vchild, n);
+ _farsetsel (_dos_ds);
- /* Adjust all children in a horizontal split. */
- for (window = w->hchild; !NILP (window); window = w->next)
+ /* The source and destination might overlap, so we need to move
+ glyphs non-destructively. */
+ if (from > to)
+ {
+ for ( ; len; from += 2, to += 2, len--)
+ _farnspokew (to, _farnspeekw (from));
+ }
+ else
{
- w = XWINDOW (window);
- IT_set_menu_bar_lines (window, n);
+ from += (len - 1) * 2;
+ to += (len - 1) * 2;
+ for ( ; len; from -= 2, to -= 2, len--)
+ _farnspokew (to, _farnspeekw (from));
}
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (ypos * screen_size_X * 2, screen_size_X);
+}
+
+/* Insert and delete glyphs. */
+static void
+IT_insert_glyphs (start, len)
+ register struct glyph *start;
+ register int len;
+{
+ int shift_by_width = screen_size_X - (new_pos_X + len);
+
+ /* Shift right the glyphs from the nominal cursor position to the
+ end of this line. */
+ IT_copy_glyphs (new_pos_X, new_pos_X + len, shift_by_width, new_pos_Y);
+
+ /* Now write the glyphs to be inserted. */
+ IT_write_glyphs (start, len);
+}
+
+static void
+IT_delete_glyphs (n)
+ register int n;
+{
+ abort ();
+}
+
+/* set-window-configuration on window.c needs this. */
+void
+x_set_menu_bar_lines (f, value, oldval)
+ struct frame *f;
+ Lisp_Object value, oldval;
+{
+ set_menu_bar_lines (f, value, oldval);
}
+/* This was copied from xfns.c */
+
+Lisp_Object Qbackground_color;
+Lisp_Object Qforeground_color;
+extern Lisp_Object Qtitle;
+
/* IT_set_terminal_modes is called when emacs is started,
resumed, and whenever the screen is redrawn! */
-static
+static void
IT_set_terminal_modes (void)
{
- char *colors;
- FRAME_PTR f;
- struct face *fp;
-
if (termscript)
fprintf (termscript, "\n<SET_TERM>");
highlight = 0;
startup_screen_size_Y = screen_size_Y;
startup_screen_attrib = ScreenAttrib;
+#if __DJGPP__ > 1
+ /* Is DOS/V (or any other RSIS software which relocates
+ the screen) installed? */
+ {
+ unsigned short es_value;
+ __dpmi_regs regs;
+
+ regs.h.ah = 0xfe; /* get relocated screen address */
+ if (ScreenPrimary == 0xb0000UL || ScreenPrimary == 0xb8000UL)
+ regs.x.es = (ScreenPrimary >> 4) & 0xffff;
+ else if (screen_old_address) /* already switched to Japanese mode once */
+ regs.x.es = (screen_old_address >> 4) & 0xffff;
+ else
+ regs.x.es = ScreenMode () == 7 ? 0xb000 : 0xb800;
+ regs.x.di = 0;
+ es_value = regs.x.es;
+ __dpmi_int (0x10, ®s);
+
+ if (regs.x.es != es_value)
+ {
+ /* screen_old_address is only set if ScreenPrimary does NOT
+ already point to the relocated buffer address returned by
+ the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
+ ScreenPrimary to that address at startup under DOS/V. */
+ if (regs.x.es != (ScreenPrimary >> 4) & 0xffff)
+ screen_old_address = ScreenPrimary;
+ screen_virtual_segment = regs.x.es;
+ screen_virtual_offset = regs.x.di;
+ ScreenPrimary = (screen_virtual_segment << 4) + screen_virtual_offset;
+ }
+ }
+#endif /* __DJGPP__ > 1 */
+
ScreenGetCursor (&startup_pos_Y, &startup_pos_X);
ScreenRetrieve (startup_screen_buffer = xmalloc (screen_size * 2));
if (termscript)
fprintf (termscript, "<SCREEN SAVED (dimensions=%dx%d)>\n",
- screen_size_X, screen_size_Y);
+ screen_size_X, screen_size_Y);
+
+ bright_bg ();
}
/* IT_reset_terminal_modes is called when emacs is
suspended or killed. */
-static
+static void
IT_reset_terminal_modes (void)
{
int display_row_start = (int) ScreenPrimary;
return;
mouse_off ();
-
+
+ /* Leave the video system in the same state as we found it,
+ as far as the blink/bright-background bit is concerned. */
+ maybe_enable_blinking ();
+
/* We have a situation here.
We cannot just do ScreenUpdate(startup_screen_buffer) because
the luser could have changed screen dimensions inside Emacs
is also restored within the visible dimensions. */
ScreenAttrib = startup_screen_attrib;
- ScreenClear ();
- if (update_row_len > saved_row_len)
- update_row_len = saved_row_len;
- if (current_rows > startup_screen_size_Y)
- current_rows = startup_screen_size_Y;
+ /* Don't restore the screen if we are exiting less than 2 seconds
+ after startup: we might be crashing, and the screen might show
+ some vital clues to what's wrong. */
+ if (clock () - startup_time >= 2*CLOCKS_PER_SEC)
+ {
+ ScreenClear ();
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (0, screen_size);
+
+ if (update_row_len > saved_row_len)
+ update_row_len = saved_row_len;
+ if (current_rows > startup_screen_size_Y)
+ current_rows = startup_screen_size_Y;
- if (termscript)
- fprintf (termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
- update_row_len / 2, current_rows);
+ if (termscript)
+ fprintf (termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
+ update_row_len / 2, current_rows);
- while (current_rows--)
- {
- dosmemput (saved_row, update_row_len, display_row_start);
- saved_row += saved_row_len;
- display_row_start += to_next_row;
+ while (current_rows--)
+ {
+ dosmemput (saved_row, update_row_len, display_row_start);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (display_row_start - ScreenPrimary,
+ update_row_len / 2);
+ saved_row += saved_row_len;
+ display_row_start += to_next_row;
+ }
}
if (startup_pos_X < cursor_pos_X)
cursor_pos_X = startup_pos_X;
term_setup_done = 0;
}
-static
-IT_set_terminal_window (void)
+static void
+IT_set_terminal_window (int foo)
+{
+}
+
+/* Remember the screen colors of the curent frame, to serve as the
+ default colors for newly-created frames. */
+
+static int initial_screen_colors[2];
+
+DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors,
+ Smsdos_remember_default_colors, 1, 1, 0,
+ "Remember the screen colors of the current frame.")
+ (frame)
+ Lisp_Object frame;
{
+ int reverse;
+ struct frame *f;
+
+ CHECK_FRAME (frame, 0);
+ f= XFRAME (frame);
+ reverse = EQ (Fcdr (Fassq (intern ("reverse"), f->param_alist)), Qt);
+
+ initial_screen_colors[0]
+ = reverse ? FRAME_BACKGROUND_PIXEL (f) : FRAME_FOREGROUND_PIXEL (f);
+ initial_screen_colors[1]
+ = reverse ? FRAME_FOREGROUND_PIXEL (f) : FRAME_BACKGROUND_PIXEL (f);
}
void
-IT_set_frame_parameters (frame, alist)
- FRAME_PTR frame;
+IT_set_frame_parameters (f, alist)
+ struct frame *f;
Lisp_Object alist;
{
Lisp_Object tail;
- int redraw;
- extern unsigned long load_color ();
- FRAME_PTR f = (FRAME_PTR) &the_only_frame;
+ int length = XINT (Flength (alist));
+ int i, j;
+ Lisp_Object *parms
+ = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
+ Lisp_Object *values
+ = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
+ Lisp_Object qreverse = intern ("reverse");
+ /* Do we have to reverse the foreground and background colors? */
+ int reverse = EQ (Fcdr (Fassq (qreverse, f->param_alist)), Qt);
+ int was_reverse = reverse;
+ int redraw = 0, fg_set = 0, bg_set = 0;
+ unsigned long orig_fg;
+ unsigned long orig_bg;
+
+ /* If we are creating a new frame, begin with the original screen colors
+ used for the initial frame. */
+ if (alist == Vdefault_frame_alist
+ && initial_screen_colors[0] != -1 && initial_screen_colors[1] != -1)
+ {
+ FRAME_FOREGROUND_PIXEL (f) = initial_screen_colors[0];
+ FRAME_BACKGROUND_PIXEL (f) = initial_screen_colors[1];
+ }
+ orig_fg = FRAME_FOREGROUND_PIXEL (f);
+ orig_bg = FRAME_BACKGROUND_PIXEL (f);
- redraw = 0;
+ /* Extract parm names and values into those vectors. */
+ i = 0;
for (tail = alist; CONSP (tail); tail = Fcdr (tail))
{
- Lisp_Object elt, prop, val;
+ Lisp_Object elt;
elt = Fcar (tail);
- prop = Fcar (elt);
- val = Fcdr (elt);
- CHECK_SYMBOL (prop, 1);
+ parms[i] = Fcar (elt);
+ CHECK_SYMBOL (parms[i], 1);
+ values[i] = Fcdr (elt);
+ i++;
+ }
- if (EQ (prop, intern ("foreground-color")))
+ j = i;
+
+ for (i = 0; i < j; i++)
+ {
+ Lisp_Object prop = parms[i];
+ Lisp_Object val = values[i];
+
+ if (EQ (prop, qreverse))
+ reverse = EQ (val, Qt);
+ }
+
+ if (termscript && reverse && !was_reverse)
+ fprintf (termscript, "<INVERSE-VIDEO>\n");
+
+ /* Now process the alist elements in reverse of specified order. */
+ for (i--; i >= 0; i--)
+ {
+ Lisp_Object prop = parms[i];
+ Lisp_Object val = values[i];
+
+ if (EQ (prop, Qforeground_color))
{
- unsigned long new_color = load_color (f, val);
+ unsigned long new_color = load_color (f, NULL, val, reverse
+ ? LFACE_BACKGROUND_INDEX
+ : LFACE_FOREGROUND_INDEX);
if (new_color != ~0)
{
- FRAME_FOREGROUND_PIXEL (f) = new_color;
+ if (reverse)
+ /* FIXME: should the fore-/background of the default
+ face change here as well? */
+ FRAME_BACKGROUND_PIXEL (f) = new_color;
+ else
+ FRAME_FOREGROUND_PIXEL (f) = new_color;
redraw = 1;
+ fg_set = 1;
+ if (termscript)
+ fprintf (termscript, "<FGCOLOR %lu>\n", new_color);
}
}
- else if (EQ (prop, intern ("background-color")))
+ else if (EQ (prop, Qbackground_color))
{
- unsigned long new_color = load_color (f, val);
+ unsigned long new_color = load_color (f, NULL, val, reverse
+ ? LFACE_FOREGROUND_INDEX
+ : LFACE_BACKGROUND_INDEX);
if (new_color != ~0)
{
- FRAME_BACKGROUND_PIXEL (f) = new_color & ~8;
+ if (reverse)
+ FRAME_FOREGROUND_PIXEL (f) = new_color;
+ else
+ FRAME_BACKGROUND_PIXEL (f) = new_color;
redraw = 1;
+ bg_set = 1;
+ if (termscript)
+ fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
}
}
- else if (EQ (prop, intern ("menu-bar-lines")))
+ else if (EQ (prop, Qtitle))
{
- int new;
- int old = FRAME_MENU_BAR_LINES (the_only_frame);
+ x_set_title (f, val);
+ if (termscript)
+ fprintf (termscript, "<TITLE: %s>\n", XSTRING (val)->data);
+ }
+ store_frame_param (f, prop, val);
+ }
- if (INTEGERP (val))
- new = XINT (val);
- else
- new = 0;
- FRAME_MENU_BAR_LINES (f) = new;
- IT_set_menu_bar_lines (the_only_frame.root_window, new - old);
+ /* If they specified "reverse", but not the colors, we need to swap
+ the current frame colors. */
+ if (reverse && !was_reverse)
+ {
+ if (!fg_set)
+ {
+ FRAME_BACKGROUND_PIXEL (f) = orig_fg;
+ redraw = 1;
+ }
+ if (!bg_set)
+ {
+ FRAME_FOREGROUND_PIXEL (f) = orig_bg;
+ redraw = 1;
}
}
if (redraw)
{
- recompute_basic_faces (f);
- Fredraw_frame (Fselected_frame ());
+ face_change_count++; /* forces xdisp.c to recompute basic faces */
+ if (f == SELECTED_FRAME())
+ redraw_frame (f);
}
}
+extern void init_frame_faces (FRAME_PTR);
+
#endif /* !HAVE_X_WINDOWS */
{
char *term = getenv ("TERM");
char *colors;
+ struct frame *sf = SELECTED_FRAME();
#ifdef HAVE_X_WINDOWS
if (!inhibit_window_system)
#ifndef HAVE_X_WINDOWS
if (!internal_terminal || inhibit_window_system)
{
- the_only_frame.output_method = output_termcap;
+ sf->output_method = output_termcap;
return;
}
Vwindow_system = intern ("pc");
Vwindow_system_version = make_number (1);
-
+ sf->output_method = output_msdos_raw;
+
+ /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
+ screen_old_address = 0;
+
+ /* Forget the stale screen colors as well. */
+ initial_screen_colors[0] = initial_screen_colors[1] = -1;
+
bzero (&the_only_x_display, sizeof the_only_x_display);
the_only_x_display.background_pixel = 7; /* White */
the_only_x_display.foreground_pixel = 0; /* Black */
+ bright_bg ();
colors = getenv ("EMACSCOLORS");
if (colors && strlen (colors) >= 2)
{
- /* Foreground colrs use 4 bits, background only 3. */
- if (isxdigit (colors[0]) && !isdigit (colors[0]))
- colors[0] += 10 - (isupper (colors[0]) ? 'A' : 'a');
+ /* The colors use 4 bits each (we enable bright background). */
+ if (isdigit (colors[0]))
+ colors[0] -= '0';
+ else if (isxdigit (colors[0]))
+ colors[0] -= (isupper (colors[0]) ? 'A' : 'a') - 10;
if (colors[0] >= 0 && colors[0] < 16)
the_only_x_display.foreground_pixel = colors[0];
- if (colors[1] >= 0 && colors[1] < 8)
+ if (isdigit (colors[1]))
+ colors[1] -= '0';
+ else if (isxdigit (colors[1]))
+ colors[1] -= (isupper (colors[1]) ? 'A' : 'a') - 10;
+ if (colors[1] >= 0 && colors[1] < 16)
the_only_x_display.background_pixel = colors[1];
}
the_only_x_display.line_height = 1;
- the_only_frame.output_data.x = &the_only_x_display;
- the_only_frame.output_method = output_msdos_raw;
the_only_x_display.font = (XFontStruct *)1; /* must *not* be zero */
- init_frame_faces ((FRAME_PTR) &the_only_frame);
+ init_frame_faces (sf);
ring_bell_hook = IT_ring_bell;
+ insert_glyphs_hook = IT_insert_glyphs;
+ delete_glyphs_hook = IT_delete_glyphs;
write_glyphs_hook = IT_write_glyphs;
cursor_to_hook = raw_cursor_to_hook = IT_cursor_to;
clear_to_end_hook = IT_clear_to_end;
update_begin_hook = IT_update_begin;
update_end_hook = IT_update_end;
reassert_line_highlight_hook = IT_reassert_line_highlight;
+ frame_up_to_date_hook = IT_cmgoto; /* position cursor when update is done */
/* These hooks are called by term.c without being checked. */
set_terminal_modes_hook = IT_set_terminal_modes;
reset_terminal_modes_hook = IT_reset_terminal_modes;
set_terminal_window_hook = IT_set_terminal_window;
+ char_ins_del_ok = 0;
#endif
}
*screen = startup_screen_buffer;
*cols = startup_screen_size_X;
*rows = startup_screen_size_Y;
- return 1;
+ return *screen != (char *)0;
#else
return 0;
#endif
}
+
+#ifndef HAVE_X_WINDOWS
+
+/* We are not X, but we can emulate it well enough for our needs... */
+void
+check_x (void)
+{
+ if (! FRAME_MSDOS_P (SELECTED_FRAME()))
+ error ("Not running under a window system");
+}
+
+#endif
+
\f
/* ----------------------- Keyboard control ----------------------
*
* SPACE
*/
+#define Ignore 0x0000
+#define Normal 0x0000 /* normal key - alt changes scan-code */
+#define FctKey 0x1000 /* func key if c == 0, else c */
+#define Special 0x2000 /* func key even if c != 0 */
+#define ModFct 0x3000 /* special if mod-keys, else 'c' */
+#define Map 0x4000 /* alt scan-code, map to unshift/shift key */
+#define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
+#define Grey 0x6000 /* Grey keypad key */
+
+#define Alt 0x0100 /* alt scan-code */
+#define Ctrl 0x0200 /* ctrl scan-code */
+#define Shift 0x0400 /* shift scan-code */
+
static int extended_kbd; /* 101 (102) keyboard present. */
+struct kbd_translate {
+ unsigned char sc;
+ unsigned char ch;
+ unsigned short code;
+};
+
struct dos_keyboard_map
{
char *unshifted;
char *shifted;
char *alt_gr;
+ struct kbd_translate *translate_table;
};
"`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
/* 0123456789012345678901234567890123456789 012345678901234 */
"~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
- 0 /* no Alt-Gr key */
+ 0, /* no Alt-Gr key */
+ 0 /* no translate table */
};
static struct dos_keyboard_map fr_keyboard = {
/* 0123456789012345678901234567890123456789012345678901234 */
" 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
/* 01234567 89012345678901234567890123456789012345678901234 */
- " ~#{[|`\\^@]} Ï "
+ " ~#{[|`\\^@]} Ï ",
+ 0 /* no translate table */
+};
+
+/*
+ * Italian keyboard support, country code 39.
+ * '<' 56:3c*0000
+ * '>' 56:3e*0000
+ * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
+ * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
+ */
+
+static struct kbd_translate it_kbd_translate_table[] = {
+ { 0x56, 0x3c, Normal | 13 },
+ { 0x56, 0x3e, Normal | 27 },
+ { 0, 0, 0 }
+};
+static struct dos_keyboard_map it_keyboard = {
+/* 0 1 2 3 4 5 */
+/* 0 123456789012345678901234567890123456789012345678901234 */
+ "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
+/* 01 23456789012345678901234567890123456789012345678901234 */
+ "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
+/* 0123456789012345678901234567890123456789012345678901234 */
+ " {}~` [] @# ",
+ it_kbd_translate_table
};
static struct dos_keyboard_map dk_keyboard = {
/* 01 23456789012345678901234567890123456789012345678901234 */
"õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
/* 0123456789012345678901234567890123456789012345678901234 */
- " @\9c$ {[]} | "
+ " @\9c$ {[]} | ",
+ 0 /* no translate table */
+};
+
+static struct kbd_translate jp_kbd_translate_table[] = {
+ { 0x73, 0x5c, Normal | 0 },
+ { 0x73, 0x5f, Normal | 0 },
+ { 0x73, 0x1c, Map | 0 },
+ { 0x7d, 0x5c, Normal | 13 },
+ { 0x7d, 0x7c, Normal | 13 },
+ { 0x7d, 0x1c, Map | 13 },
+ { 0, 0, 0 }
+};
+static struct dos_keyboard_map jp_keyboard = {
+/* 0 1 2 3 4 5 */
+/* 0123456789012 345678901234567890123456789012345678901234 */
+ "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
+/* 01 23456789012345678901234567890123456789012345678901234 */
+ "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
+ 0, /* no Alt-Gr key */
+ jp_kbd_translate_table
};
static struct keyboard_layout_list
{
1, &us_keyboard,
33, &fr_keyboard,
- 45, &dk_keyboard
+ 39, &it_keyboard,
+ 45, &dk_keyboard,
+ 81, &jp_keyboard
};
static struct dos_keyboard_map *keyboard;
static int keyboard_map_all;
+static int international_keyboard;
int
dos_set_keyboard (code, always)
int always;
{
int i;
+ _go32_dpmi_registers regs;
+
+ /* See if Keyb.Com is installed (for international keyboard support).
+ Note: calling Int 2Fh via int86 wedges the DOS box on some versions
+ of Windows 9X! So don't do that! */
+ regs.x.ax = 0xad80;
+ regs.x.ss = regs.x.sp = regs.x.flags = 0;
+ _go32_dpmi_simulate_int (0x2f, ®s);
+ if (regs.h.al == 0xff)
+ international_keyboard = 1;
/* Initialize to US settings, for countries that don't have their own. */
keyboard = keyboard_layout_list[0].keyboard_map;
return 0;
}
\f
-#define Ignore 0x0000
-#define Normal 0x0000 /* normal key - alt changes scan-code */
-#define FctKey 0x1000 /* func key if c == 0, else c */
-#define Special 0x2000 /* func key even if c != 0 */
-#define ModFct 0x3000 /* special if mod-keys, else 'c' */
-#define Map 0x4000 /* alt scan-code, map to unshift/shift key */
-#define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
-#define Grey 0x6000 /* Grey keypad key */
-
-#define Alt 0x0100 /* alt scan-code */
-#define Ctrl 0x0200 /* ctrl scan-code */
-#define Shift 0x0400 /* shift scan-code */
-
static struct
{
unsigned char char_code; /* normal code */
Ignore, /* Right shift */
Grey | 1, /* Grey * */
Ignore, /* Alt */
- Normal | ' ', /* ' ' */
+ Normal | 55, /* ' ' */
Ignore, /* Caps Lock */
FctKey | 0xbe, /* F1 */
FctKey | 0xbf, /* F2 */
mask |= SUPER_P;
modifiers |= super_modifier;
}
+ else if (!international_keyboard)
+ {
+ /* If Keyb.Com is NOT installed, let Right Alt behave
+ like the Left Alt. */
+ mask &= ~ALT_GR_P;
+ mask |= ALT_P;
+ }
}
- if (regs.h.ah & 1) /* Left CTRL pressed
+ if (regs.h.ah & 1) /* Left CTRL pressed ? */
mask |= CTRL_P;
if (regs.h.ah & 4) /* Right CTRL pressed ? */
/* Get a char from keyboard. Function keys are put into the event queue. */
+extern void kbd_buffer_store_event (struct input_event *);
+static int mouse_preempted = 0; /* non-zero when XMenu gobbles mouse events */
+
static int
dos_rawgetc ()
{
union REGS regs;
#ifndef HAVE_X_WINDOWS
- SCREEN_SET_CURSOR ();
- if (!mouse_visible) mouse_on ();
+ /* Maybe put the cursor where it should be. */
+ IT_cmgoto (SELECTED_FRAME());
#endif
-
+
/* The following condition is equivalent to `kbhit ()', except that
it uses the bios to do its job. This pleases DESQview/X. */
while ((regs.h.ah = extended_kbd ? 0x11 : 0x01),
{
union REGS regs;
register unsigned char c;
- int sc, code, mask, kp_mode;
+ int sc, code = -1, mask, kp_mode;
int modifiers;
regs.h.ah = extended_kbd ? 0x10 : 0x00;
}
else
{
- if (sc >= (sizeof (ibmpc_translate_map) / sizeof (short)))
- continue;
- if ((code = ibmpc_translate_map[sc]) == Ignore)
- continue;
+ /* Try the keyboard-private translation table first. */
+ if (keyboard->translate_table)
+ {
+ struct kbd_translate *p = keyboard->translate_table;
+
+ while (p->sc)
+ {
+ if (p->sc == sc && p->ch == c)
+ {
+ code = p->code;
+ break;
+ }
+ p++;
+ }
+ }
+ /* If the private table didn't translate it, use the general
+ one. */
+ if (code == -1)
+ {
+ if (sc >= (sizeof (ibmpc_translate_map) / sizeof (short)))
+ continue;
+ if ((code = ibmpc_translate_map[sc]) == Ignore)
+ continue;
+ }
}
if (c == 0)
{
- if (code & Alt)
+ /* We only look at the keyboard Ctrl/Shift/Alt keys when
+ Emacs is ready to read a key. Therefore, if they press
+ `Alt-x' when Emacs is busy, by the time we get to
+ `dos_get_modifiers', they might have already released the
+ Alt key, and Emacs gets just `x', which is BAD.
+ However, for keys with the `Map' property set, the ASCII
+ code returns zero iff Alt is pressed. So, when we DON'T
+ have to support international_keyboard, we don't have to
+ distinguish between the left and right Alt keys, and we
+ can set the META modifier for any keys with the `Map'
+ property if they return zero ASCII code (c = 0). */
+ if ( (code & Alt)
+ || ( (code & 0xf000) == Map && !international_keyboard))
modifiers |= meta_modifier;
if (code & Ctrl)
modifiers |= ctrl_modifier;
event.kind = ascii_keystroke;
event.code = code;
event.modifiers = modifiers;
- XSETFRAME (event.frame_or_window, selected_frame);
+ event.frame_or_window = selected_frame;
event.timestamp = event_timestamp ();
kbd_buffer_store_event (&event);
}
- if (have_mouse > 0)
+ if (have_mouse > 0 && !mouse_preempted)
{
int but, press, x, y, ok;
| (press ? down_modifier : up_modifier);
event.x = x;
event.y = y;
- XSETFRAME (event.frame_or_window, selected_frame);
+ event.frame_or_window = selected_frame;
event.timestamp = event_timestamp ();
kbd_buffer_store_event (&event);
}
FRAME_PTR f;
register int pix_x, pix_y;
register int *x, *y;
- void /* XRectangle */ *bounds;
+ XRectangle *bounds;
int noclip;
{
if (bounds) abort ();
IT_menu_display (XMenu *menu, int y, int x, int *faces)
{
int i, j, face, width;
- GLYPH *text, *p;
+ struct glyph *text, *p;
char *q;
int mx, my;
int enabled, mousehere;
int row, col;
+ struct frame *sf = SELECTED_FRAME();
width = menu->width;
- text = (GLYPH *) xmalloc ((width + 2) * sizeof (GLYPH));
+ text = (struct glyph *) xmalloc ((width + 2) * sizeof (struct glyph));
ScreenGetCursor (&row, &col);
mouse_get_xy (&mx, &my);
- IT_update_begin ();
+ IT_update_begin (sf);
for (i = 0; i < menu->count; i++)
{
IT_cursor_to (y + i, x);
mousehere = (y + i == my && x <= mx && mx < x + width + 2);
face = faces[enabled + mousehere * 2];
p = text;
- *p++ = FAST_MAKE_GLYPH (' ', face);
+ SET_CHAR_GLYPH (*p, ' ', face, 0);
+ p++;
for (j = 0, q = menu->text[i]; *q; j++)
- *p++ = FAST_MAKE_GLYPH (*q++, face);
- for (; j < width; j++)
- *p++ = FAST_MAKE_GLYPH (' ', face);
- *p++ = FAST_MAKE_GLYPH (menu->submenu[i] ? 16 : ' ', face);
+ {
+ if (*q > 26)
+ {
+ SET_CHAR_GLYPH (*p, *q++, face, 0);
+ p++;
+ }
+ else /* make '^x' */
+ {
+ SET_CHAR_GLYPH (*p, '^', face, 0);
+ p++;
+ j++;
+ SET_CHAR_GLYPH (*p, *q++ + 64, face, 0);
+ p++;
+ }
+ }
+
+ for (; j < width; j++, p++)
+ SET_CHAR_GLYPH (*p, ' ', face, 0);
+
+ SET_CHAR_GLYPH (*p, menu->submenu[i] ? 16 : ' ', face, 0);
+ p++;
IT_write_glyphs (text, width + 2);
}
- IT_update_end ();
+ IT_update_end (sf);
IT_cursor_to (row, col);
xfree (text);
}
XMenuAddPane (Display *foo, XMenu *menu, char *txt, int enable)
{
int len;
+ char *p;
if (!enable)
abort ();
menu->text[menu->count] = txt;
menu->panenumber[menu->count] = ++menu->panecount;
menu->count++;
- if ((len = strlen (txt)) > menu->width)
+
+ /* Adjust length for possible control characters (which will
+ be written as ^x). */
+ for (len = strlen (txt), p = txt; *p; p++)
+ if (*p < 27)
+ len++;
+
+ if (len > menu->width)
menu->width = len;
+
return menu->panecount;
}
int foo, char *txt, int enable)
{
int len;
+ char *p;
if (pane)
if (!(menu = IT_menu_search_pane (menu, pane)))
menu->text[menu->count] = txt;
menu->panenumber[menu->count] = enable;
menu->count++;
- if ((len = strlen (txt)) > menu->width)
+
+ /* Adjust length for possible control characters (which will
+ be written as ^x). */
+ for (len = strlen (txt), p = txt; *p; p++)
+ if (*p < 27)
+ len++;
+
+ if (len > menu->width)
menu->width = len;
+
return XM_SUCCESS;
}
int statecount;
int x, y, i, b;
int screensize;
- int faces[4], selectface;
+ int faces[4];
+ Lisp_Object selectface;
int leave, result, onepane;
int title_faces[4]; /* face to display the menu title */
+ int buffers_num_deleted = 0;
+ struct frame *sf = SELECTED_FRAME();
/* Just in case we got here without a mouse present... */
if (have_mouse <= 0)
return XM_IA_SELECT;
+ /* Don't allow non-positive x0 and y0, lest the menu will wrap
+ around the display. */
+ if (x0 <= 0)
+ x0 = 1;
+ if (y0 <= 0)
+ y0 = 1;
+
+ /* We will process all the mouse events directly, so we had
+ better prevented dos_rawgetc from stealing them from us. */
+ mouse_preempted++;
state = alloca (menu->panecount * sizeof (struct IT_menu_state));
screensize = screen_size * 2;
faces[0]
- = compute_glyph_face (&the_only_frame,
- face_name_id_number
- (&the_only_frame,
- intern ("msdos-menu-passive-face")),
- 0);
+ = lookup_derived_face (sf, intern ("msdos-menu-passive-face"),
+ CHARSET_ASCII, DEFAULT_FACE_ID);
faces[1]
- = compute_glyph_face (&the_only_frame,
- face_name_id_number
- (&the_only_frame,
- intern ("msdos-menu-active-face")),
- 0);
- selectface
- = face_name_id_number (&the_only_frame, intern ("msdos-menu-select-face"));
- faces[2] = compute_glyph_face (&the_only_frame, selectface, faces[0]);
- faces[3] = compute_glyph_face (&the_only_frame, selectface, faces[1]);
+ = lookup_derived_face (sf, intern ("msdos-menu-active-face"),
+ CHARSET_ASCII, DEFAULT_FACE_ID);
+ selectface = intern ("msdos-menu-select-face");
+ faces[2] = lookup_derived_face (sf, selectface,
+ CHARSET_ASCII, faces[0]);
+ faces[3] = lookup_derived_face (sf, selectface,
+ CHARSET_ASCII, faces[1]);
/* Make sure the menu title is always displayed with
`msdos-menu-active-face', no matter where the mouse pointer is. */
title_faces[i] = faces[3];
statecount = 1;
+
+ /* Don't let the title for the "Buffers" popup menu include a
+ digit (which is ugly).
+
+ This is a terrible kludge, but I think the "Buffers" case is
+ the only one where the title includes a number, so it doesn't
+ seem to be necessary to make this more general. */
+ if (strncmp (menu->text[0], "Buffers 1", 9) == 0)
+ {
+ menu->text[0][7] = '\0';
+ buffers_num_deleted = 1;
+ }
state[0].menu = menu;
mouse_off ();
ScreenRetrieve (state[0].screen_behind = xmalloc (screensize));
+ /* Turn off the cursor. Otherwise it shows through the menu
+ panes, which is ugly. */
+ IT_display_cursor (0);
+
IT_menu_display (menu, y0 - 1, x0 - 1, title_faces); /* display menu title */
+ if (buffers_num_deleted)
+ menu->text[0][7] = ' ';
if ((onepane = menu->count == 1 && menu->submenu[0]))
{
menu->width = menu->submenu[0]->width;
{
if (!mouse_visible) mouse_on ();
mouse_check_moved ();
- if (selected_frame->mouse_moved)
+ if (sf->mouse_moved)
{
- selected_frame->mouse_moved = 0;
+ sf->mouse_moved = 0;
result = XM_IA_SELECT;
mouse_get_xy (&x, &y);
for (i = 0; i < statecount; i++)
statecount--;
mouse_off ();
ScreenUpdate (state[statecount].screen_behind);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (0, screen_size);
xfree (state[statecount].screen_behind);
}
if (i == statecount - 1 && state[i].menu->submenu[dy])
state[statecount - 1].x,
faces);
}
- for (b = 0; b < mouse_button_count; b++)
+ else
+ /* We are busy-waiting for the mouse to move, so let's be nice
+ to other Windows applications by releasing our time slice. */
+ __dpmi_yield ();
+ for (b = 0; b < mouse_button_count && !leave; b++)
{
- (void) mouse_pressed (b, &x, &y);
- if (mouse_released (b, &x, &y))
- leave = 1;
+ /* Only leave if user both pressed and released the mouse, and in
+ that order. This avoids popping down the menu pane unless
+ the user is really done with it. */
+ if (mouse_pressed (b, &x, &y))
+ {
+ while (mouse_button_depressed (b, &x, &y))
+ __dpmi_yield ();
+ leave = 1;
+ }
+ (void) mouse_released (b, &x, &y);
}
}
mouse_off ();
ScreenUpdate (state[0].screen_behind);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (0, screen_size);
while (statecount--)
xfree (state[statecount].screen_behind);
+ IT_display_cursor (1); /* turn cursor back on */
+ /* Clean up any mouse events that are waiting inside Emacs event queue.
+ These events are likely to be generated before the menu was even
+ displayed, probably because the user pressed and released the button
+ (which invoked the menu) too quickly. If we don't remove these events,
+ Emacs will process them after we return and surprise the user. */
+ discard_mouse_events ();
+ /* Allow mouse events generation by dos_rawgetc. */
+ mouse_preempted--;
return result;
}
\f
/* ----------------------- DOS / UNIX conversion --------------------- */
+void msdos_downcase_filename (unsigned char *);
+
/* Destructively turn backslashes into slashes. */
void
dostounix_filename (p)
register char *p;
{
+ msdos_downcase_filename (p);
+
while (*p)
{
if (*p == '\\')
unixtodos_filename (p)
register char *p;
{
+ if (p[1] == ':' && *p >= 'A' && *p <= 'Z')
+ {
+ *p += 'a' - 'A';
+ p += 2;
+ }
+
while (*p)
{
if (*p == '/')
int drive;
char *dst;
{
- union REGS regs;
+ char in_path[4], *p = in_path;
+ int e = errno;
- *dst++ = (drive) ? drive + 'A' - 1 : getdisk () + 'A';
- *dst++ = ':'
- *dst++ = '/';
- regs.h.dl = drive;
-#if __DJGPP__ > 1
- /* regs.x.si can be 16 or 32 bits, depending on whether _NAIVE_DOS_REGS
- or _BORLAND_DOS_REGS have or haven't been defined. We should work
- with either, so use regs.d.esi which is always 32 bit-wide. */
- regs.d.esi = (int) dst;
-#else
- regs.x.si = (int) dst;
-#endif
- regs.h.ah = 0x47;
- intdos (®s, ®s);
- return !regs.x.cflag;
+ /* Generate "X:." (when drive is X) or "." (when drive is 0). */
+ if (drive != 0)
+ {
+ *p++ = drive + 'A' - 1;
+ *p++ = ':';
+ }
+
+ *p++ = '.';
+ *p = '\0';
+ errno = 0;
+ _fixpath (in_path, dst);
+ /* _fixpath can set errno to ENOSYS on non-LFN systems because
+ it queries the LFN support, so ignore that error. */
+ if ((errno && errno != ENOSYS) || *dst == '\0')
+ return 0;
+
+ msdos_downcase_filename (dst);
+
+ errno = e;
+ return 1;
}
/* Remove all CR's that are followed by a LF. */
unsigned char *np = buf;
unsigned char *startp = buf;
unsigned char *endp = buf + n;
- unsigned char c;
if (n == 0)
return n;
}
}
+/* A low-level file-renaming function which works around Windows 95 bug.
+ This is pulled directly out of DJGPP v2.01 library sources, and only
+ used when you compile with DJGPP v2.0. */
+
+#include <io.h>
+
+int _rename(const char *old, const char *new)
+{
+ __dpmi_regs r;
+ int olen = strlen(old) + 1;
+ int i;
+ int use_lfn = _USE_LFN;
+ char tempfile[FILENAME_MAX];
+ const char *orig = old;
+ int lfn_fd = -1;
+
+ r.x.dx = __tb_offset;
+ r.x.di = __tb_offset + olen;
+ r.x.ds = r.x.es = __tb_segment;
+
+ if (use_lfn)
+ {
+ /* Windows 95 bug: for some filenames, when you rename
+ file -> file~ (as in Emacs, to leave a backup), the
+ short 8+3 alias doesn't change, which effectively
+ makes OLD and NEW the same file. We must rename
+ through a temporary file to work around this. */
+
+ char *pbase = 0, *p;
+ static char try_char[] = "abcdefghijklmnopqrstuvwxyz012345789";
+ int idx = sizeof(try_char) - 1;
+
+ /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
+ might point to another drive, which will fail the DOS call. */
+ strcpy(tempfile, old);
+ for (p = tempfile; *p; p++) /* ensure temporary is on the same drive */
+ if (*p == '/' || *p == '\\' || *p == ':')
+ pbase = p;
+ if (pbase)
+ pbase++;
+ else
+ pbase = tempfile;
+ strcpy(pbase, "X$$djren$$.$$temp$$");
+
+ do
+ {
+ if (idx <= 0)
+ return -1;
+ *pbase = try_char[--idx];
+ } while (_chmod(tempfile, 0) != -1);
+
+ r.x.ax = 0x7156;
+ _put_path2(tempfile, olen);
+ _put_path(old);
+ __dpmi_int(0x21, &r);
+ if (r.x.flags & 1)
+ {
+ errno = __doserr_to_errno(r.x.ax);
+ return -1;
+ }
+
+ /* Now create a file with the original name. This will
+ ensure that NEW will always have a 8+3 alias
+ different from that of OLD. (Seems to be required
+ when NameNumericTail in the Registry is set to 0.) */
+ lfn_fd = _creat(old, 0);
+
+ olen = strlen(tempfile) + 1;
+ old = tempfile;
+ r.x.di = __tb_offset + olen;
+ }
+
+ for (i=0; i<2; i++)
+ {
+ if(use_lfn)
+ r.x.ax = 0x7156;
+ else
+ r.h.ah = 0x56;
+ _put_path2(new, olen);
+ _put_path(old);
+ __dpmi_int(0x21, &r);
+ if(r.x.flags & 1)
+ {
+ if (r.x.ax == 5 && i == 0) /* access denied */
+ remove(new); /* and try again */
+ else
+ {
+ errno = __doserr_to_errno(r.x.ax);
+
+ /* Restore to original name if we renamed it to temporary. */
+ if (use_lfn)
+ {
+ if (lfn_fd != -1)
+ {
+ _close (lfn_fd);
+ remove (orig);
+ }
+ _put_path2(orig, olen);
+ _put_path(tempfile);
+ r.x.ax = 0x7156;
+ __dpmi_int(0x21, &r);
+ }
+ return -1;
+ }
+ }
+ else
+ break;
+ }
+
+ /* Success. Delete the file possibly created to work
+ around the Windows 95 bug. */
+ if (lfn_fd != -1)
+ return (_close (lfn_fd) == 0) ? remove (orig) : -1;
+ return 0;
+}
+
#endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
+DEFUN ("msdos-long-file-names", Fmsdos_long_file_names, Smsdos_long_file_names,
+ 0, 0, 0,
+ "Return non-nil if long file names are supported on MSDOS.")
+ ()
+{
+ return (_USE_LFN ? Qt : Qnil);
+}
+
+/* Convert alphabetic characters in a filename to lower-case. */
+
+void
+msdos_downcase_filename (p)
+ register unsigned char *p;
+{
+ /* Always lower-case drive letters a-z, even if the filesystem
+ preserves case in filenames.
+ This is so MSDOS filenames could be compared by string comparison
+ functions that are case-sensitive. Even case-preserving filesystems
+ do not distinguish case in drive letters. */
+ if (p[1] == ':' && *p >= 'A' && *p <= 'Z')
+ {
+ *p += 'a' - 'A';
+ p += 2;
+ }
+
+ /* Under LFN we expect to get pathnames in their true case. */
+ if (NILP (Fmsdos_long_file_names ()))
+ for ( ; *p; p++)
+ if (*p >= 'A' && *p <= 'Z')
+ *p += 'a' - 'A';
+}
+
+DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename, Smsdos_downcase_filename,
+ 1, 1, 0,
+ "Convert alphabetic characters in FILENAME to lower case and return that.\n\
+When long filenames are supported, doesn't change FILENAME.\n\
+If FILENAME is not a string, returns nil.\n\
+The argument object is never altered--the value is a copy.")
+ (filename)
+ Lisp_Object filename;
+{
+ Lisp_Object tem;
+
+ if (! STRINGP (filename))
+ return Qnil;
+ tem = Fcopy_sequence (filename);
+ msdos_downcase_filename (XSTRING (tem)->data);
+ return tem;
+}
\f
/* The Emacs root directory as determined by init_environment. */
{
char *s, *t, *root;
int len;
+ static const char * const tempdirs[] = {
+ "$TMPDIR", "$TEMP", "$TMP", "c:/"
+ };
+ int i;
+ const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
+
+ /* Make sure they have a usable $TMPDIR. Many Emacs functions use
+ temporary files and assume "/tmp" if $TMPDIR is unset, which
+ will break on DOS/Windows. Refuse to work if we cannot find
+ a directory, not even "c:/", usable for that purpose. */
+ for (i = 0; i < imax ; i++)
+ {
+ const char *tmp = tempdirs[i];
+
+ if (*tmp == '$')
+ tmp = getenv (tmp + 1);
+ /* Note that `access' can lie to us if the directory resides on a
+ read-only filesystem, like CD-ROM or a write-protected floppy.
+ The only way to be really sure is to actually create a file and
+ see if it succeeds. But I think that's too much to ask. */
+ if (tmp && access (tmp, D_OK) == 0)
+ {
+ setenv ("TMPDIR", tmp, 1);
+ break;
+ }
+ }
+ if (i >= imax)
+ cmd_error_internal
+ (Fcons (Qerror,
+ Fcons (build_string ("no usable temporary directories found!!"),
+ Qnil)),
+ "While setting TMPDIR: ");
+
+ /* Note the startup time, so we know not to clear the screen if we
+ exit immediately; see IT_reset_terminal_modes.
+ (Yes, I know `clock' returns zero the first time it's called, but
+ I do this anyway, in case some wiseguy changes that at some point.) */
+ startup_time = clock ();
/* Find our root from argv[0]. Assuming argv[0] is, say,
"c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
root = alloca (MAXPATHLEN + 20);
_fixpath (argv[0], root);
- strlwr (root);
+ msdos_downcase_filename (root);
len = strlen (root);
while (len > 0 && root[len] != '/' && root[len] != ':')
len--;
root[len] = '\0';
- if (len > 4 && strcmp (root + len - 4, "/bin") == 0)
+ if (len > 4
+ && (strcmp (root + len - 4, "/bin") == 0
+ || strcmp (root + len - 4, "/src") == 0)) /* under a debugger */
root[len - 4] = '\0';
else
- strcpy (root, "c:/emacs"); /* Only under debuggers, I think. */
+ strcpy (root, "c:/emacs"); /* let's be defensive */
len = strlen (root);
strcpy (emacsroot, root);
if (!s) s = "c:/command.com";
t = alloca (strlen (s) + 1);
strcpy (t, s);
- strlwr (t);
dostounix_filename (t);
setenv ("SHELL", t, 0);
/* Current directory is always considered part of MsDos's path but it is
not normally mentioned. Now it is. */
strcat (strcpy (t, ".;"), s);
- strlwr (t);
dostounix_filename (t); /* Not a single file name, but this should work. */
setenv ("PATH", t, 1);
file TEMPOUT and stderr to TEMPERR. */
int
-run_msdos_command (argv, dir, tempin, tempout, temperr)
+run_msdos_command (argv, working_dir, tempin, tempout, temperr, envv)
unsigned char **argv;
- Lisp_Object dir;
+ const char *working_dir;
int tempin, tempout, temperr;
+ char **envv;
{
- char *saveargv1, *saveargv2, **envv;
+ char *saveargv1, *saveargv2, *lowcase_argv0, *pa, *pl;
char oldwd[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS. */
int msshell, result = -1;
- int in, out, inbak, outbak, errbak;
+ int inbak, outbak, errbak;
int x, y;
Lisp_Object cmd;
/* Get current directory as MSDOS cwd is not per-process. */
getwd (oldwd);
- cmd = Ffile_name_nondirectory (build_string (argv[0]));
+ /* If argv[0] is the shell, it might come in any lettercase.
+ Since `Fmember' is case-sensitive, we need to downcase
+ argv[0], even if we are on case-preserving filesystems. */
+ lowcase_argv0 = alloca (strlen (argv[0]) + 1);
+ for (pa = argv[0], pl = lowcase_argv0; *pa; pl++)
+ {
+ *pl = *pa++;
+ if (*pl >= 'A' && *pl <= 'Z')
+ *pl += 'a' - 'A';
+ }
+ *pl = '\0';
+
+ cmd = Ffile_name_nondirectory (build_string (lowcase_argv0));
msshell = !NILP (Fmember (cmd, Fsymbol_value (intern ("msdos-shells"))))
&& !strcmp ("-c", argv[1]);
if (msshell)
}
}
- /* Build the environment array. */
- {
- extern Lisp_Object Vprocess_environment;
- Lisp_Object tmp, lst;
- int i, len;
-
- lst = Vprocess_environment;
- len = XFASTINT (Flength (lst));
-
- envv = alloca ((len + 1) * sizeof (char *));
- for (i = 0; i < len; i++)
- {
- tmp = Fcar (lst);
- lst = Fcdr (lst);
- CHECK_STRING (tmp, 0);
- envv[i] = alloca (XSTRING (tmp)->size + 1);
- strcpy (envv[i], XSTRING (tmp)->data);
- }
- envv[len] = (char *) 0;
- }
-
- if (STRINGP (dir))
- chdir (XSTRING (dir)->data);
+ chdir (working_dir);
inbak = dup (0);
outbak = dup (1);
errbak = dup (2);
dup2 (tempout, 1);
dup2 (temperr, 2);
+#if __DJGPP__ > 1
+
+ if (msshell && !argv[3])
+ {
+ /* MS-DOS native shells are too restrictive. For starters, they
+ cannot grok commands longer than 126 characters. In DJGPP v2
+ and later, `system' is much smarter, so we'll call it instead. */
+
+ const char *cmnd;
+
+ /* A shell gets a single argument--its full command
+ line--whose original was saved in `saveargv2'. */
+
+ /* Don't let them pass empty command lines to `system', since
+ with some shells it will try to invoke an interactive shell,
+ which will hang Emacs. */
+ for (cmnd = saveargv2; *cmnd && isspace (*cmnd); cmnd++)
+ ;
+ if (*cmnd)
+ {
+ extern char **environ;
+ int save_system_flags = __system_flags;
+
+ /* Request the most powerful version of `system'. We need
+ all the help we can get to avoid calling stock DOS shells. */
+ __system_flags = (__system_redirect
+ | __system_use_shell
+ | __system_allow_multiple_cmds
+ | __system_allow_long_cmds
+ | __system_handle_null_commands
+ | __system_emulate_chdir);
+
+ environ = envv;
+ result = system (cmnd);
+ __system_flags = save_system_flags;
+ }
+ else
+ result = 0; /* emulate Unixy shell behavior with empty cmd line */
+ }
+ else
+
+#endif /* __DJGPP__ > 1 */
+
result = spawnve (P_WAIT, argv[0], argv, envv);
dup2 (inbak, 0);
dup2 (outbak, 1);
dup2 (errbak, 2);
- close (inbak);
- close (outbak);
- close (errbak);
+ emacs_close (inbak);
+ emacs_close (outbak);
+ emacs_close (errbak);
dos_ttraw ();
if (have_mouse > 0)
mouse_init ();
mouse_moveto (x, y);
}
+
+ /* Some programs might change the meaning of the highest bit of the
+ text attribute byte, so we get blinking characters instead of the
+ bright background colors. Restore that. */
+ bright_bg ();
done:
chdir (oldwd);
nice (p) int p; {}
void volatile pause () {}
sigsetmask (x) int x; { return 0; }
+sigblock (mask) int mask; { return 0; }
#endif
-request_sigio () {}
+void request_sigio (void) {}
setpgrp () {return 0; }
setpriority (x,y,z) int x,y,z; { return 0; }
+void unrequest_sigio (void) {}
+
+#if __DJGPP__ > 1
+
+#ifdef POSIX_SIGNALS
+
+/* Augment DJGPP library POSIX signal functions. This is needed
+ as of DJGPP v2.01, but might be in the library in later releases. */
+
+#include <libc/bss.h>
+
+/* A counter to know when to re-initialize the static sets. */
+static int sigprocmask_count = -1;
+
+/* Which signals are currently blocked (initially none). */
+static sigset_t current_mask;
+
+/* Which signals are pending (initially none). */
+static sigset_t pending_signals;
+
+/* Previous handlers to restore when the blocked signals are unblocked. */
+typedef void (*sighandler_t)(int);
+static sighandler_t prev_handlers[320];
+
+/* A signal handler which just records that a signal occured
+ (it will be raised later, if and when the signal is unblocked). */
+static void
+sig_suspender (signo)
+ int signo;
+{
+ sigaddset (&pending_signals, signo);
+}
+
+int
+sigprocmask (how, new_set, old_set)
+ int how;
+ const sigset_t *new_set;
+ sigset_t *old_set;
+{
+ int signo;
+ sigset_t new_mask;
+
+ /* If called for the first time, initialize. */
+ if (sigprocmask_count != __bss_count)
+ {
+ sigprocmask_count = __bss_count;
+ sigemptyset (&pending_signals);
+ sigemptyset (¤t_mask);
+ for (signo = 0; signo < 320; signo++)
+ prev_handlers[signo] = SIG_ERR;
+ }
+
+ if (old_set)
+ *old_set = current_mask;
+
+ if (new_set == 0)
+ return 0;
+
+ if (how != SIG_BLOCK && how != SIG_UNBLOCK && how != SIG_SETMASK)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ sigemptyset (&new_mask);
+
+ /* DJGPP supports upto 320 signals. */
+ for (signo = 0; signo < 320; signo++)
+ {
+ if (sigismember (¤t_mask, signo))
+ sigaddset (&new_mask, signo);
+ else if (sigismember (new_set, signo) && how != SIG_UNBLOCK)
+ {
+ sigaddset (&new_mask, signo);
+
+ /* SIGKILL is silently ignored, as on other platforms. */
+ if (signo != SIGKILL && prev_handlers[signo] == SIG_ERR)
+ prev_handlers[signo] = signal (signo, sig_suspender);
+ }
+ if (( how == SIG_UNBLOCK
+ && sigismember (&new_mask, signo)
+ && sigismember (new_set, signo))
+ || (how == SIG_SETMASK
+ && sigismember (&new_mask, signo)
+ && !sigismember (new_set, signo)))
+ {
+ sigdelset (&new_mask, signo);
+ if (prev_handlers[signo] != SIG_ERR)
+ {
+ signal (signo, prev_handlers[signo]);
+ prev_handlers[signo] = SIG_ERR;
+ }
+ if (sigismember (&pending_signals, signo))
+ {
+ sigdelset (&pending_signals, signo);
+ raise (signo);
+ }
+ }
+ }
+ current_mask = new_mask;
+ return 0;
+}
+
+#else /* not POSIX_SIGNALS */
+
+sigsetmask (x) int x; { return 0; }
sigblock (mask) int mask; { return 0; }
-unrequest_sigio () {}
+
+#endif /* not POSIX_SIGNALS */
+#endif /* __DJGPP__ > 1 */
#ifndef HAVE_SELECT
#include "sysselect.h"
&& (long)(time).tv_usec <= 0))
#endif
+/* This yields the rest of the current time slice to the task manager.
+ It should be called by any code which knows that it has nothing
+ useful to do except idle.
+
+ I don't use __dpmi_yield here, since versions of library before 2.02
+ called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
+ on some versions of Windows 9X. */
+
+void
+dos_yield_time_slice (void)
+{
+ _go32_dpmi_registers r;
+
+ r.x.ax = 0x1680;
+ r.x.ss = r.x.sp = r.x.flags = 0;
+ _go32_dpmi_simulate_int (0x2f, &r);
+ if (r.h.al == 0x80)
+ errno = ENOSYS;
+}
/* Only event queue is checked. */
/* We don't have to call timer_check here
{
while (!detect_input_pending ())
{
-#if __DJGPP__ >= 2
- __dpmi_yield ();
-#endif
+ dos_yield_time_slice ();
}
}
else
if (EMACS_TIME_ZERO_OR_NEG_P (*timeout))
return 0;
cllast = clnow;
-#if __DJGPP__ >= 2
- __dpmi_yield ();
-#endif
+ dos_yield_time_slice ();
}
}
ScreenSetCursor (10, 0);
cputs ("\r\n\nEmacs aborted!\r\n");
#if __DJGPP__ > 1
+#if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (2 * 10 * screen_size_X, 4 * screen_size_X);
/* Generate traceback, so we could tell whodunit. */
signal (SIGINT, SIG_DFL);
__asm__ __volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
+#else /* __DJGPP_MINOR__ >= 2 */
+ raise (SIGABRT);
+#endif /* __DJGPP_MINOR__ >= 2 */
#endif
exit (2);
}
#endif
+/* The following variables are required so that cus-start.el won't
+ complain about unbound variables. */
+#ifndef HAVE_X_WINDOWS
+/* Search path for bitmap files (xfns.c). */
+Lisp_Object Vx_bitmap_file_path;
+int x_stretch_cursor_p;
+#endif
+#ifndef subprocesses
+/* Nonzero means delete a process right away if it exits (process.c). */
+static int delete_exited_processes;
+#endif
+
syms_of_msdos ()
{
recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
staticpro (&recent_doskeys);
+#ifndef HAVE_X_WINDOWS
+ DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
+ "List of directories to search for bitmap files for X.");
+ Vx_bitmap_file_path = decode_env_path ((char *) 0, ".");
+
+ DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
+ "*Non-nil means draw block cursor as wide as the glyph under it.\n\
+For example, if a block cursor is over a tab, it will be drawn as\n\
+wide as that tab on the display. (No effect on MS-DOS.)");
+ x_stretch_cursor_p = 0;
+
+ /* The following three are from xfns.c: */
+ Qbackground_color = intern ("background-color");
+ staticpro (&Qbackground_color);
+ Qforeground_color = intern ("foreground-color");
+ staticpro (&Qforeground_color);
+
+ DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph,
+ "*Glyph to display instead of chars not supported by current codepage.\n\
+
+This variable is used only by MSDOS terminals.");
+ Vdos_unsupported_char_glyph = '\177';
+#endif
+#ifndef subprocesses
+ DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
+ "*Non-nil means delete processes immediately when they exit.\n\
+nil means don't delete them until `list-processes' is run.");
+ delete_exited_processes = 0;
+#endif
defsubr (&Srecent_doskeys);
+ defsubr (&Smsdos_long_file_names);
+ defsubr (&Smsdos_downcase_filename);
+ defsubr (&Smsdos_remember_default_colors);
}
#endif /* MSDOS */
+
HCoop / bpt / emacs.git / blobdiff