-/* MS-DOS specific C utilities.
+/* MS-DOS specific C utilities. -*- coding: raw-text -*-
Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of GNU Emacs.
}
}
+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;
+
+ /* Clear the mouse-moved flag for every frame on this display. */
+ FOR_EACH_FRAME (tail, frame)
+ XFRAME (frame)->mouse_moved = 0;
- regs.x.ax = 0x0003;
- int86 (0x33, ®s, ®s);
*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
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);
/* 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;
+
+#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;
+
+ 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
dos_direct_output (y, x, buf, len)
int y;
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) {
/* 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
/* 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)
{
ScreenAttrib = (FACE_BACKGROUND (fp) << 4) | FACE_FOREGROUND (fp);
}
-static
+static void
IT_write_glyphs (GLYPH *str, int len)
{
int newface;
int ch, l = len;
unsigned char *buf, *bp;
+ int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
if (len == 0) return;
}
mouse_off_maybe ();
- dosmemput (buf, 2 * len,
- (int)ScreenPrimary + 2 * (new_pos_X + screen_size_X * new_pos_Y));
+ dosmemput (buf, 2 * len, (int)ScreenPrimary + offset);
+ if (screen_virtual_segment)
+ dosv_refresh_virtual_screen (offset, len);
new_pos_X += len;
}
-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);
IT_set_face (0);
if (termscript)
}
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);
}
-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)
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
-IT_cmgoto (f)
- FRAME_PTR f;
+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 = MODIFF == unchanged_modified;
-
- /* If we are in the echo area, put the cursor at the end of text. */
+ static int previous_pos_X = -1;
+
+ /* 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)
{
- new_pos_X = FRAME_DESIRED_GLYPHS (f)->used[new_pos_Y];
- update_cursor_pos = 1;
+ 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;
+ }
}
if (update_cursor_pos
mouse_on ();
}
-static
-IT_reassert_line_highlight (new, vpos)
- int new, vpos;
+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 vpos, int first_unused_hpos)
{
highlight = new_highlight;
IT_set_face (0); /* To possibly clear the highlighting. */
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 ()
-{
-}
-
-/* This was more or less copied from xterm.c
-
- Nowadays, the corresponding function under X is `x_set_menu_bar_lines_1'
- on xfns.c */
-
static void
-IT_set_menu_bar_lines (window, n)
- Lisp_Object window;
- int n;
+IT_update_end (struct frame *foo)
{
- struct window *w = XWINDOW (window);
-
- XSETFASTINT (w->last_modified, 0);
- XSETFASTINT (w->last_overlay_modified, 0);
- XSETFASTINT (w->top, XFASTINT (w->top) + n);
- XSETFASTINT (w->height, XFASTINT (w->height) - n);
-
- /* Handle just the top child in a vertical split. */
- if (!NILP (w->vchild))
- IT_set_menu_bar_lines (w->vchild, n);
-
- /* Adjust all children in a horizontal split. */
- for (window = w->hchild; !NILP (window); window = w->next)
- {
- w = XWINDOW (window);
- IT_set_menu_bar_lines (window, n);
- }
}
-/* This was copied from xfns.c */
-
-Lisp_Object Qbackground_color;
-Lisp_Object Qforeground_color;
-
+/* set-window-configuration on window.c needs this. */
void
x_set_menu_bar_lines (f, value, oldval)
struct frame *f;
Lisp_Object value, oldval;
{
- int nlines;
- int olines = FRAME_MENU_BAR_LINES (f);
-
- /* Right now, menu bars don't work properly in minibuf-only frames;
- most of the commands try to apply themselves to the minibuffer
- frame itslef, and get an error because you can't switch buffers
- in or split the minibuffer window. */
- if (FRAME_MINIBUF_ONLY_P (f))
- return;
+ set_menu_bar_lines (f, value, oldval);
+}
- if (INTEGERP (value))
- nlines = XINT (value);
- else
- nlines = 0;
+/* This was copied from xfns.c */
- FRAME_MENU_BAR_LINES (f) = nlines;
- IT_set_menu_bar_lines (f->root_window, nlines - olines);
-}
+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)
{
if (termscript)
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 && 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;
ScreenAttrib = startup_screen_attrib;
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;
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;
}
term_setup_done = 0;
}
-static
-IT_set_terminal_window (void)
+static void
+IT_set_terminal_window (int foo)
{
}
Lisp_Object prop = parms[i];
Lisp_Object val = values[i];
- if (EQ (prop, intern ("foreground-color")))
+ if (EQ (prop, Qforeground_color))
{
unsigned long new_color = load_color (f, val);
if (new_color != ~0)
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);
if (new_color != ~0)
fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
}
}
- else if (EQ (prop, intern ("menu-bar-lines")))
- x_set_menu_bar_lines (f, val, 0);
+ else if (EQ (prop, Qtitle))
+ {
+ x_set_title (f, val);
+ if (termscript)
+ fprintf (termscript, "<TITLE: %s>\n", XSTRING (val)->data);
+ }
+ else if (EQ (prop, intern ("reverse")) && EQ (val, Qt))
+ {
+ unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
+ FRAME_FOREGROUND_PIXEL (f) = FRAME_BACKGROUND_PIXEL (f);
+ FRAME_BACKGROUND_PIXEL (f) = fg;
+ if (termscript)
+ fprintf (termscript, "<INVERSE-VIDEO>\n");
+ }
store_frame_param (f, prop, val);
}
Vwindow_system = intern ("pc");
Vwindow_system_version = make_number (1);
-
+
+ /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
+ screen_old_address = 0;
+
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 */
*screen = startup_screen_buffer;
*cols = startup_screen_size_X;
*rows = startup_screen_size_Y;
- return 1;
+ return *screen != (char *)0;
#else
return 0;
#endif
" ~#{[|`\\^@]} Ï "
};
+/*
+ * 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 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 */
+ " {}~` [] @# "
+};
+
static struct dos_keyboard_map dk_keyboard = {
/* 0 1 2 3 4 5 */
/* 0123456789012345678901234567890123456789012345678901234 */
{
1, &us_keyboard,
33, &fr_keyboard,
+ 39, &it_keyboard,
45, &dk_keyboard
};
int always;
{
int i;
- union REGS regs;
+ _go32_dpmi_registers regs;
- /* See if Keyb.Com is installed (for international keyboard support). */
+ /* 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;
- int86 (0x2f, ®s, ®s);
+ regs.x.ss = regs.x.sp = regs.x.flags = 0;
+ _go32_dpmi_simulate_int (0x2f, ®s);
if (regs.h.al == 0xff)
international_keyboard = 1;
/* 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 ()
kbd_buffer_store_event (&event);
}
- if (have_mouse > 0)
+ if (have_mouse > 0 && !mouse_preempted)
{
int but, press, x, y, ok;
FRAME_PTR f;
register int pix_x, pix_y;
register int *x, *y;
- void /* XRectangle */ *bounds;
+ XRectangle *bounds;
int noclip;
{
if (bounds) abort ();
text = (GLYPH *) xmalloc ((width + 2) * sizeof (GLYPH));
ScreenGetCursor (&row, &col);
mouse_get_xy (&mx, &my);
- IT_update_begin ();
+ IT_update_begin (selected_frame);
for (i = 0; i < menu->count; i++)
{
IT_cursor_to (y + i, x);
*p++ = FAST_MAKE_GLYPH (menu->submenu[i] ? 16 : ' ', face);
IT_write_glyphs (text, width + 2);
}
- IT_update_end ();
+ IT_update_end (selected_frame);
IT_cursor_to (row, col);
xfree (text);
}
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]
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;
}
{
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: ");
/* Find our root from argv[0]. Assuming argv[0] is, say,
"c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
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, *lowcase_argv0, *pa, *pl;
+ char *saveargv1, *saveargv2, *lowcase_argv0, *pa, *pl;
char oldwd[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS. */
int msshell, result = -1;
int inbak, outbak, errbak;
}
}
- /* 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);
cannot grok commands longer than 126 characters. In DJGPP v2
and later, `system' is much smarter, so we'll call it instead. */
- extern char **environ;
- environ = envv;
+ const char *cmnd;
/* A shell gets a single argument--its full command
line--whose original was saved in `saveargv2'. */
- result = system (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
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; }
-unrequest_sigio () {}
+void unrequest_sigio (void) {}
#if __DJGPP__ > 1
&& (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);
+#endif /* __DJGPP_MINOR__ < 2 */
/* Generate traceback, so we could tell whodunit. */
signal (SIGINT, SIG_DFL);
__asm__ __volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
}
#endif
+/* The following two are required so that customization feature
+ won't complain about unbound variables. */
+#ifndef HAVE_X_WINDOWS
+/* Search path for bitmap files (xfns.c). */
+Lisp_Object Vx_bitmap_file_path;
+#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, ".");
+
+ /* The following two are from xfns.c: */
+ Qbackground_color = intern ("background-color");
+ staticpro (&Qbackground_color);
+ Qforeground_color = intern ("foreground-color");
+ staticpro (&Qforeground_color);
+#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);
}
#endif /* MSDOS */
+
HCoop / bpt / emacs.git / blobdiff