#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"
#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
#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. */
&& XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top) <= new_pos_Y)
{
new_pos_X = FRAME_DESIRED_GLYPHS (f)->used[new_pos_Y];
- FRAME_CURSOR_X (f) = new_pos_X;
update_cursor_pos = 1;
}
static
IT_set_terminal_modes (void)
{
- char *colors;
- FRAME_PTR f;
- struct face *fp;
-
if (termscript)
fprintf (termscript, "\n<SET_TERM>");
highlight = 0;
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
FRAME_FOREGROUND_PIXEL (f) = new_color;
redraw = 1;
if (termscript)
- fprintf (termscript, "<FGCOLOR %d>\n", new_color);
+ fprintf (termscript, "<FGCOLOR %lu>\n", new_color);
}
}
else if (EQ (prop, intern ("background-color")))
FRAME_BACKGROUND_PIXEL (f) = new_color;
redraw = 1;
if (termscript)
- fprintf (termscript, "<BGCOLOR %d>\n", new_color);
+ fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
}
}
else if (EQ (prop, intern ("menu-bar-lines")))
if (redraw)
{
+ extern void recompute_basic_faces (FRAME_PTR);
+ extern void redraw_frame (FRAME_PTR);
+
recompute_basic_faces (f);
if (f == selected_frame)
redraw_frame (f);
}
}
+extern void init_frame_faces (FRAME_PTR);
+
#endif /* !HAVE_X_WINDOWS */
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;
+ union REGS regs;
+
+ /* See if Keyb.Com is installed (for international keyboard support). */
+ regs.x.ax = 0xad80;
+ int86 (0x2f, ®s, ®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;
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 ? */
/* Get a char from keyboard. Function keys are put into the event queue. */
+extern void kbd_buffer_store_event (struct input_event *);
+
static int
dos_rawgetc ()
{
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;
/* 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;
state = alloca (menu->panecount * sizeof (struct IT_menu_state));
screensize = screen_size * 2;
unsigned char *np = buf;
unsigned char *startp = buf;
unsigned char *endp = buf + n;
- unsigned char c;
if (n == 0)
return n;
(filename)
Lisp_Object filename;
{
- char *fname;
Lisp_Object tem;
if (! STRINGP (filename))
char *saveargv1, *saveargv2, **envv, *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;
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 () {}
setpgrp () {return 0; }
setpriority (x,y,z) int x,y,z; { return 0; }
-sigblock (mask) int mask; { return 0; }
unrequest_sigio () {}
+#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; }
+
+#endif /* not POSIX_SIGNALS */
+#endif /* __DJGPP__ > 1 */
+
#ifndef HAVE_SELECT
#include "sysselect.h"