/* MS-DOS specific C utilities. -*- coding: raw-text -*-
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
- 2003, 2004, 2005, 2006, 2007, 2008
+ 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#ifdef MSDOS
+#include <setjmp.h>
#include "lisp.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <dos.h>
#include <errno.h>
-#include <string.h> /* for bzero and string functions */
+#include <string.h> /* for memset and string functions */
#include <sys/stat.h> /* for _fixpath */
#include <unistd.h> /* for chdir, dup, dup2, etc. */
#include <dir.h> /* for getdisk */
-#if __DJGPP__ >= 2
#pragma pack(0) /* dir.h does a pack(4), which isn't GCC's default */
#include <fcntl.h>
#include <io.h> /* for setmode */
#include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
#include <libc/dosio.h> /* for _USE_LFN */
#include <conio.h> /* for cputs */
-#endif
#include "msdos.h"
#include "systime.h"
+#include "frame.h"
#include "termhooks.h"
#include "termchar.h"
#include "dispextern.h"
#include "character.h"
#include "coding.h"
#include "disptab.h"
-#include "frame.h"
#include "window.h"
#include "buffer.h"
#include "commands.h"
#define _dos_ds _go32_info_block.selector_for_linear_memory
#endif
-#if __DJGPP__ > 1
-
#include <signal.h>
#include "syssignal.h"
#endif /* GNU_MALLOC */
#endif /* not SYSTEM_MALLOC */
-#endif /* __DJGPP__ > 1 */
static unsigned long
-event_timestamp ()
+event_timestamp (void)
{
struct time t;
unsigned long s;
static int mouse_button_count;
void
-mouse_on ()
+mouse_on (void)
{
union REGS regs;
if (have_mouse > 0 && !mouse_visible)
{
- if (termscript)
- fprintf (termscript, "<M_ON>");
+ struct tty_display_info *tty = CURTTY ();
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "<M_ON>");
regs.x.ax = 0x0001;
int86 (0x33, ®s, ®s);
mouse_visible = 1;
}
void
-mouse_off ()
+mouse_off (void)
{
union REGS regs;
if (have_mouse > 0 && mouse_visible)
{
- if (termscript)
- fprintf (termscript, "<M_OFF>");
+ struct tty_display_info *tty = CURTTY ();
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "<M_OFF>");
regs.x.ax = 0x0002;
int86 (0x33, ®s, ®s);
mouse_visible = 0;
}
void
-mouse_moveto (x, y)
- int x, y;
+mouse_moveto (int x, int y)
{
union REGS regs;
+ struct tty_display_info *tty = CURTTY ();
- if (termscript)
- fprintf (termscript, "<M_XY=%dx%d>", x, y);
+ if (tty->termscript)
+ fprintf (tty->termscript, "<M_XY=%dx%d>", x, y);
regs.x.ax = 0x0004;
mouse_last_x = regs.x.cx = x * 8;
mouse_last_y = regs.x.dx = y * 8;
}
static int
-mouse_pressed (b, xp, yp)
- int b, *xp, *yp;
+mouse_pressed (int b, int *xp, int *yp)
{
union REGS regs;
}
static int
-mouse_released (b, xp, yp)
- int b, *xp, *yp;
+mouse_released (int b, int *xp, int *yp)
{
union REGS regs;
}
static int
-mouse_button_depressed (b, xp, yp)
- int b, *xp, *yp;
+mouse_button_depressed (int b, int *xp, int *yp)
{
union REGS regs;
}
void
-mouse_get_pos (f, insist, bar_window, part, x, y, time)
- FRAME_PTR *f;
- int insist;
- Lisp_Object *bar_window, *x, *y;
- enum scroll_bar_part *part;
- unsigned long *time;
+mouse_get_pos (FRAME_PTR *f, int insist, Lisp_Object *bar_window,
+ enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
+ unsigned long *time)
{
int ix, iy;
Lisp_Object frame, tail;
}
static void
-mouse_check_moved ()
+mouse_check_moved (void)
{
int x, y;
}
void
-mouse_init ()
+mouse_init (void)
{
union REGS regs;
+ struct tty_display_info *tty = CURTTY ();
- if (termscript)
- fprintf (termscript, "<M_INIT>");
+ if (tty->termscript)
+ fprintf (tty->termscript, "<M_INIT>");
regs.x.ax = 0x0021;
int86 (0x33, ®s, ®s);
static unsigned short outside_cursor;
/* Similar to the_only_frame. */
-struct x_output the_only_x_display;
+struct tty_display_info the_only_display_info;
/* Support for DOS/V (allows Japanese characters to be displayed on
standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
colors for newly-created frames. */
static int initial_screen_colors[2];
-#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
regs.x.cx = count;
__dpmi_int (0x10, ®s);
}
-#endif
static void
-dos_direct_output (y, x, buf, len)
- int x, y;
- char *buf;
- int len;
+dos_direct_output (int y, int x, char *buf, int len)
{
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
-
-/* Flash the screen as a substitute for BEEPs. */
-
-#if (__DJGPP__ < 2)
-static void
-do_visible_bell (xorattr)
- unsigned char xorattr;
-{
- asm volatile
- (" movb $1,%%dl \n\
-visible_bell_0: \n\
- movl _ScreenPrimary,%%eax \n\
- call dosmemsetup \n\
- movl %%eax,%%ebx \n\
- movl %1,%%ecx \n\
- movb %0,%%al \n\
- incl %%ebx \n\
-visible_bell_1: \n\
- xorb %%al,%%gs:(%%ebx) \n\
- addl $2,%%ebx \n\
- decl %%ecx \n\
- jne visible_bell_1 \n\
- decb %%dl \n\
- jne visible_bell_3 \n\
-visible_bell_2: \n\
- movzwl %%ax,%%eax \n\
- movzwl %%ax,%%eax \n\
- movzwl %%ax,%%eax \n\
- movzwl %%ax,%%eax \n\
- decw %%cx \n\
- jne visible_bell_2 \n\
- jmp visible_bell_0 \n\
-visible_bell_3:"
- : /* no output */
- : "m" (xorattr), "g" (screen_size)
- : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
-}
-
-static void
-ScreenVisualBell (void)
-{
- /* This creates an xor-mask that will swap the default fore- and
- background colors. */
- do_visible_bell (((FRAME_FOREGROUND_PIXEL (SELECTED_FRAME ())
- ^ FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()))
- * 0x11) & 0x7f);
}
#endif
ROWS x COLS frame. */
void
-dos_set_window_size (rows, cols)
- int *rows, *cols;
+dos_set_window_size (int *rows, int *cols)
{
char video_name[30];
union REGS regs;
/* If the user specified a special video mode for these dimensions,
use that mode. */
sprintf (video_name, "screen-dimensions-%dx%d", *rows, *cols);
- video_mode = XSYMBOL (Fintern_soft (build_string (video_name),
- Qnil))-> value;
+ video_mode = Fsymbol_value (Fintern_soft (build_string (video_name), Qnil));
if (INTEGERP (video_mode)
&& (video_mode_value = XINT (video_mode)) > 0)
/* Find one of the dimensions supported by standard EGA/VGA
which gives us at least the required dimensions. */
-
-#if __DJGPP__ > 1
-
else
{
static struct {
}
}
-#else /* not __DJGPP__ > 1 */
-
- else if (*rows <= 25)
- {
- if (current_rows != 25 || current_cols != 80)
- {
- regs.x.ax = 3;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 0x1101;
- regs.h.bl = 0;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 0x1200;
- regs.h.bl = 32;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 3;
- int86 (0x10, ®s, ®s);
- }
- }
- else if (*rows <= 50)
- if (have_vga && (current_rows != 50 || current_cols != 80)
- || *rows <= 43 && (current_rows != 43 || current_cols != 80))
- {
- regs.x.ax = 3;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 0x1112;
- regs.h.bl = 0;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 0x1200;
- regs.h.bl = 32;
- int86 (0x10, ®s, ®s);
- regs.x.ax = 0x0100;
- regs.x.cx = 7;
- int86 (0x10, ®s, ®s);
- }
-#endif /* not __DJGPP__ > 1 */
if (have_mouse)
{
screen_size_Y = *rows;
screen_size = *cols * *rows;
-#if __DJGPP__ > 1
/* If the dimensions changed, the mouse highlight info is invalid. */
if (current_rows != *rows || current_cols != *cols)
{
struct frame *f = SELECTED_FRAME();
- struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Lisp_Object window = dpyinfo->mouse_face_window;
if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
dpyinfo->mouse_face_window = Qnil;
}
}
-#endif
/* Enable bright background colors. */
bright_bg ();
the mouse cursor may need to be refreshed. */
static void
-mouse_off_maybe ()
+mouse_off_maybe (void)
{
int x, y;
static void
msdos_set_cursor_shape (struct frame *f, int start_line, int width)
{
-#if __DJGPP__ > 1
unsigned desired_cursor;
__dpmi_regs regs;
int max_line, top_line, bot_line;
+ struct tty_display_info *tty = FRAME_TTY (f);
/* Avoid the costly BIOS call if F isn't the currently selected
frame. Allow for NULL as unconditionally meaning the selected
if (f && f != SELECTED_FRAME())
return;
- if (termscript)
- fprintf (termscript, "\nCURSOR SHAPE=(%d,%d)", start_line, width);
+ if (tty->termscript)
+ fprintf (tty->termscript, "\nCURSOR SHAPE=(%d,%d)", start_line, width);
/* The character cell size in scan lines is stored at 40:85 in the
BIOS data area. */
regs.h.ah = 1;
regs.x.cx = desired_cursor;
__dpmi_int (0x10, ®s);
-#endif /* __DJGPP__ > 1 */
}
static void
}
static void
-IT_ring_bell (void)
+IT_ring_bell (struct frame *f)
{
if (visible_bell)
{
struct face *fp = FACE_FROM_ID (sf, face);
struct face *dfp = FACE_FROM_ID (sf, DEFAULT_FACE_ID);
unsigned long fg, bg, dflt_fg, dflt_bg;
+ struct tty_display_info *tty = FRAME_TTY (sf);
if (!fp)
{
fg = bg;
bg = tem2;
}
- if (termscript)
- fprintf (termscript, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face,
+ if (tty->termscript)
+ fprintf (tty->termscript, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face,
fp->foreground, fp->background, fg, bg);
if (fg >= 0 && fg < 16)
{
}
}
-Lisp_Object Vdos_unsupported_char_glyph;
+/* According to RBIL (INTERRUP.A, V-1000), 160 is the maximum possible
+ width of a DOS display in any known text mode. We multiply by 2 to
+ accomodate the screen attribute byte. */
+#define MAX_SCREEN_BUF 160*2
+Lisp_Object Vdos_unsupported_char_glyph;
+extern unsigned char *encode_terminal_code (struct glyph *, int,
+ struct coding_system *);
static void
-IT_write_glyphs (struct glyph *str, int str_len)
+IT_write_glyphs (struct frame *f, struct glyph *str, int str_len)
{
- unsigned char *screen_buf, *screen_bp, *screen_buf_end, *bp;
- int unsupported_face = 0;
- unsigned unsupported_char = '\177';
+ unsigned char screen_buf[MAX_SCREEN_BUF], *screen_bp, *bp;
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;
-
- /* If terminal_coding does any conversion, use it, otherwise use
- safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
- because it always returns 1 if terminal_coding.src_multibyte is 1. */
- struct coding_system *coding =
- (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
- ? &terminal_coding
- : &safe_terminal_coding);
+ struct tty_display_info *tty = FRAME_TTY (f);
struct frame *sf;
+ unsigned char *conversion_buffer;
/* Do we need to consider conversion of unibyte characters to
multibyte? */
= (NILP (current_buffer->enable_multibyte_characters)
&& unibyte_display_via_language_environment);
- unsigned char conversion_buffer[256];
- int conversion_buffer_size = sizeof conversion_buffer;
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always returns 1 if terminal_coding.src_multibyte is 1. */
+ struct coding_system *coding = FRAME_TERMINAL_CODING (f);
- if (str_len <= 0) return;
+ if (!(coding->common_flags & CODING_REQUIRE_ENCODING_MASK))
+ coding = &safe_terminal_coding;
- /* Set up the unsupported character glyph */
- if (!NILP (Vdos_unsupported_char_glyph))
- {
- unsupported_char = GLYPH_CHAR (XINT (Vdos_unsupported_char_glyph));
- unsupported_face = GLYPH_FACE (XINT (Vdos_unsupported_char_glyph));
- }
+ if (str_len <= 0) return;
- 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
/* 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)
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
+ screen_bp = &screen_buf[0];
+ while (sl > 0)
{
- int cf, chlen, enclen;
- unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *buf;
- unsigned ch;
-
- /* 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
- {
- GLYPH g;
- int glyph_not_in_table = 0;
-
- SET_GLYPH_FROM_CHAR_GLYPH (g, *str);
-
- if (GLYPH_INVALID_P (g) || GLYPH_SIMPLE_P (tbase, tlen, g))
- {
- /* This glyph doesn't have an entry in Vglyph_table. */
- ch = str->u.ch;
- glyph_not_in_table = 1;
- }
- else
- {
- /* This glyph has an entry in Vglyph_table, so process
- any aliases before testing for simpleness. */
- GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
- ch = GLYPH_CHAR (g);
- }
-
- /* Convert the character code to multibyte, if they
- requested display via language environment. We only want
- to convert unibyte characters to multibyte in unibyte
- buffers! Otherwise, the 8-bit value in CH came 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 (! CHAR_VALID_P (ch, 0))
- {
- ch = !NILP (Vdos_unsupported_char_glyph)
- ? XINT (Vdos_unsupported_char_glyph)
- : '\177';
- SET_GLYPH_CHAR (g, ch);
- }
-
- /* If the face of this glyph is different from the current
- screen face, update the screen attribute byte. */
- cf = str->face_id;
- if (cf != screen_face)
- IT_set_face (cf); /* handles invalid faces gracefully */
-
- if (glyph_not_in_table || GLYPH_SIMPLE_P (tbase, tlen, g))
- {
- /* We generate the multi-byte form of CH in WORKBUF. */
- chlen = CHAR_STRING (ch, workbuf);
- buf = workbuf;
- }
- 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
- {
- coding->src_multibyte = 1;
- 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 == '?')
- {
- unsigned char *cbp = conversion_buffer;
+ int cf;
+ int n;
+
+ /* If the face of this glyph is different from the current
+ screen face, update the screen attribute byte. */
+ cf = str->face_id;
+ if (cf != screen_face)
+ IT_set_face (cf); /* handles invalid faces gracefully */
+
+ /* Identify a run of glyphs with the same face. */
+ for (n = 1; n < sl; ++n)
+ if (str[n].face_id != cf)
+ break;
- while (cbp < conversion_buffer + enclen && *cbp == '?')
- *cbp++ = unsupported_char;
- if (unsupported_face != screen_face)
- IT_set_face (unsupported_face);
- }
- }
+ if (n >= sl)
+ /* This is the last glyph. */
+ coding->mode |= CODING_MODE_LAST_BLOCK;
- 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
+ conversion_buffer = encode_terminal_code (str, n, coding);
+ if (coding->produced > 0)
+ {
+ /* Copy the encoded bytes to the screen buffer. */
+ for (bp = conversion_buffer; coding->produced--; bp++)
{
- /* 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++)
+ /* Paranoia: discard bytes that would overrun the end of
+ the screen buffer. */
+ if (screen_bp - screen_buf <= MAX_SCREEN_BUF - 2)
{
*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--;
+ if (tty->termscript)
+ fputc (*bp, tty->termscript);
}
}
+ /* Update STR and its remaining length. */
+ str += n;
+ sl -= n;
}
- /* Dump whatever is left in the screen buffer. */
+ /* Dump whatever we have in the screen buffer. */
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;
-
- /* 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)
- {
- screen_buf = alloca (coding->produced * 2);
- 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;
- }
- }
}
/************************************************************************
/* Display the active region described by mouse_face_*
in its mouse-face if HL > 0, in its normal face if HL = 0. */
static void
-show_mouse_face (struct display_info *dpyinfo, int hl)
+show_mouse_face (struct tty_display_info *dpyinfo, int hl)
{
struct window *w = XWINDOW (dpyinfo->mouse_face_window);
struct frame *f = XFRAME (WINDOW_FRAME (w));
int i;
struct face *fp;
+ struct tty_display_info *tty = FRAME_TTY (f);
/* If window is in the process of being destroyed, don't bother
int offset = ScreenPrimary + 2*(vpos*screen_size_X + kstart) + 1;
int start_offset = offset;
- if (termscript)
- fprintf (termscript, "\n<MH+ %d-%d:%d>",
+ if (tty->termscript)
+ fprintf (tty->termscript, "\n<MH+ %d-%d:%d>",
kstart, kstart + nglyphs - 1, vpos);
mouse_off ();
new_pos_X = start_hpos + WINDOW_LEFT_EDGE_X (w);
new_pos_Y = row->y + WINDOW_TOP_EDGE_Y (w);
- if (termscript)
- fprintf (termscript, "<MH- %d-%d:%d>",
+ if (tty->termscript)
+ fprintf (tty->termscript, "<MH- %d-%d:%d>",
new_pos_X, new_pos_X + nglyphs - 1, new_pos_Y);
- IT_write_glyphs (row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
- if (termscript)
- fputs ("\n", termscript);
+ IT_write_glyphs (f, row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
+ if (tty->termscript)
+ fputs ("\n", tty->termscript);
new_pos_X = save_x;
new_pos_Y = save_y;
}
/* Clear out the mouse-highlighted active region.
Redraw it un-highlighted first. */
static void
-clear_mouse_face (struct display_info *dpyinfo)
+clear_mouse_face (struct tty_display_info *dpyinfo)
{
if (!dpyinfo->mouse_face_hidden && ! NILP (dpyinfo->mouse_face_window))
show_mouse_face (dpyinfo, 0);
IT_note_mode_line_highlight (struct window *w, int x, int mode_line_p)
{
struct frame *f = XFRAME (w->frame);
- struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
struct glyph_row *row;
if (mode_line_p)
static void
IT_note_mouse_highlight (struct frame *f, int x, int y)
{
- struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
enum window_part part = ON_NOTHING;
Lisp_Object window;
struct window *w;
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
&ignore, pos + 1,
- !dpyinfo->mouse_face_hidden);
+ !dpyinfo->mouse_face_hidden,
+ -1);
/* Display it as active. */
show_mouse_face (dpyinfo, 1);
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
&ignore, pos + 1,
- !dpyinfo->mouse_face_hidden);
+ !dpyinfo->mouse_face_hidden,
+ -1);
/* Display it as active. */
show_mouse_face (dpyinfo, 1);
}
static void
-IT_clear_end_of_line (int first_unused)
+IT_clear_end_of_line (struct frame *f, int first_unused)
{
char *spaces, *sp;
int i, j, offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
extern int fatal_error_in_progress;
+ struct tty_display_info *tty = FRAME_TTY (f);
if (new_pos_X >= first_unused || fatal_error_in_progress)
return;
IT_set_face (0);
i = (j = first_unused - new_pos_X) * 2;
- if (termscript)
- fprintf (termscript, "<CLR:EOL[%d..%d)>", new_pos_X, first_unused);
+ if (tty->termscript)
+ fprintf (tty->termscript, "<CLR:EOL[%d..%d)>", new_pos_X, first_unused);
spaces = sp = alloca (i);
while (--j >= 0)
}
static void
-IT_clear_screen (void)
+IT_clear_screen (struct frame *f)
{
- if (termscript)
- fprintf (termscript, "<CLR:SCR>");
+ struct tty_display_info *tty = FRAME_TTY (f);
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "<CLR:SCR>");
/* We are sometimes called (from clear_garbaged_frames) when a new
frame is being created, but its faces are not yet realized. In
such a case we cannot call IT_set_face, since it will fail to find
}
static void
-IT_clear_to_end (void)
+IT_clear_to_end (struct frame *f)
{
- if (termscript)
- fprintf (termscript, "<CLR:EOS>");
+ struct tty_display_info *tty = FRAME_TTY (f);
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "<CLR:EOS>");
while (new_pos_Y < screen_size_Y) {
new_pos_X = 0;
- IT_clear_end_of_line (screen_size_X);
+ IT_clear_end_of_line (f, screen_size_X);
new_pos_Y++;
}
}
static void
-IT_cursor_to (int y, int x)
+IT_cursor_to (struct frame *f, int y, int x)
{
- if (termscript)
- fprintf (termscript, "\n<XY=%dx%d>", x, y);
+ struct tty_display_info *tty = FRAME_TTY (f);
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "\n<XY=%dx%d>", x, y);
new_pos_X = x;
new_pos_Y = y;
}
static void
IT_display_cursor (int on)
{
- if (termscript)
- fprintf (termscript, "\nCURSOR %s", on ? "ON" : "OFF");
+ struct tty_display_info *tty = CURTTY ();
+
if (on && cursor_cleared)
{
ScreenSetCursor (current_pos_Y, current_pos_X);
cursor_cleared = 0;
+ if (tty->termscript)
+ fprintf (tty->termscript, "\nCURSOR ON");
}
else if (!on && !cursor_cleared)
{
ScreenSetCursor (-1, -1);
cursor_cleared = 1;
+ if (tty->termscript)
+ fprintf (tty->termscript, "\nCURSOR OFF");
}
}
/* 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; */
+ struct tty_display_info *tty = FRAME_TTY (f);
/* FIXME: This needs to be rewritten for the new redisplay, or
removed. */
&& (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);
+ if (tty->termscript)
+ fprintf (tty->termscript, "\n<CURSOR:%dx%d>", current_pos_X, current_pos_Y);
}
/* Maybe cursor is invisible, so make it visible. */
static void
IT_update_begin (struct frame *f)
{
- struct display_info *display_info = FRAME_X_DISPLAY_INFO (f);
+ struct tty_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
struct frame *mouse_face_frame = display_info->mouse_face_mouse_frame;
+ if (display_info->termscript)
+ fprintf (display_info->termscript, "\n\n<UPDATE_BEGIN");
+
BLOCK_INPUT;
if (f && f == mouse_face_frame)
static void
IT_update_end (struct frame *f)
{
- FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
+ if (dpyinfo->termscript)
+ fprintf (dpyinfo->termscript, "\n<UPDATE_END\n");
+ dpyinfo->mouse_face_defer = 0;
}
static void
IT_frame_up_to_date (struct frame *f)
{
- struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
Lisp_Object new_cursor, frame_desired_cursor;
struct window *sw;
/* Insert and delete glyphs. */
static void
-IT_insert_glyphs (start, len)
- register struct glyph *start;
- register int len;
+IT_insert_glyphs (struct frame *f, struct glyph *start, int len)
{
int shift_by_width = screen_size_X - (new_pos_X + len);
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);
+ IT_write_glyphs (f, start, len);
}
static void
-IT_delete_glyphs (n)
- register int n;
+IT_delete_glyphs (struct frame *f, 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;
+x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
set_menu_bar_lines (f, value, oldval);
}
resumed, and whenever the screen is redrawn! */
static void
-IT_set_terminal_modes (void)
+IT_set_terminal_modes (struct terminal *term)
{
- if (termscript)
- fprintf (termscript, "\n<SET_TERM>");
+ struct tty_display_info *tty;
+
+ /* If called with initial terminal, it's too early to do anything
+ useful. */
+ if (term->type == output_initial)
+ return;
+
+ tty = term->display_info.tty;
+
+ if (tty->termscript)
+ fprintf (tty->termscript, "\n<SET_TERM>");
screen_size_X = ScreenCols ();
screen_size_Y = ScreenRows ();
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? */
{
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);
-
bright_bg ();
}
suspended or killed. */
static void
-IT_reset_terminal_modes (void)
+IT_reset_terminal_modes (struct terminal *term)
{
int display_row_start = (int) ScreenPrimary;
int saved_row_len = startup_screen_size_X * 2;
int to_next_row = update_row_len;
unsigned char *saved_row = startup_screen_buffer;
int cursor_pos_X = ScreenCols () - 1, cursor_pos_Y = ScreenRows () - 1;
+ struct tty_display_info *tty = term->display_info.tty;
- if (termscript)
- fprintf (termscript, "\n<RESET_TERM>");
+ if (tty->termscript)
+ fprintf (tty->termscript, "\n<RESET_TERM>");
if (!term_setup_done)
return;
if (current_rows > startup_screen_size_Y)
current_rows = startup_screen_size_Y;
- if (termscript)
- fprintf (termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
+ if (tty->termscript)
+ fprintf (tty->termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
update_row_len / 2, current_rows);
while (current_rows--)
ScreenSetCursor (cursor_pos_Y, cursor_pos_X);
xfree (startup_screen_buffer);
+ startup_screen_buffer = NULL;
term_setup_done = 0;
}
static void
-IT_set_terminal_window (int foo)
+IT_set_terminal_window (struct frame *f, int foo)
{
}
struct frame *f;
CHECK_FRAME (frame);
- f= XFRAME (frame);
+ f = XFRAME (frame);
/* This function is called after applying default-frame-alist to the
initial frame. At that time, if reverse-colors option was
specified in default-frame-alist, it was already applied, and
- frame colors are reversed. We need to account for that. */
- if (EQ (Fcdr (Fassq (Qreverse, f->param_alist)), Qt))
- {
- initial_screen_colors[0] = FRAME_BACKGROUND_PIXEL (f);
- initial_screen_colors[1] = FRAME_FOREGROUND_PIXEL (f);
- }
- else
- {
- initial_screen_colors[0] = FRAME_FOREGROUND_PIXEL (f);
- initial_screen_colors[1] = FRAME_BACKGROUND_PIXEL (f);
- }
+ frame colors are reversed. */
+ initial_screen_colors[0] = FRAME_FOREGROUND_PIXEL (f);
+ initial_screen_colors[1] = FRAME_BACKGROUND_PIXEL (f);
}
void
-IT_set_frame_parameters (f, alist)
- struct frame *f;
- Lisp_Object alist;
+IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
{
Lisp_Object tail;
int i, j, length = XINT (Flength (alist));
= (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
/* Do we have to reverse the foreground and background colors? */
int reverse = EQ (Fcdr (Fassq (Qreverse, f->param_alist)), Qt);
- int need_to_reverse, was_reverse = reverse;
int redraw = 0, fg_set = 0, bg_set = 0;
unsigned long orig_fg, orig_bg;
Lisp_Object frame_bg, frame_fg;
- extern Lisp_Object Qdefault, QCforeground, QCbackground;
+ struct tty_display_info *tty = FRAME_TTY (f);
+ extern Lisp_Object Qmenu_bar_lines;
+ extern Lisp_Object Vmenu_bar_mode;
+ int menu_bar_lines_defined =
+ !NILP (Fassq (Qmenu_bar_lines, Vdefault_frame_alist));
/* If we are creating a new frame, begin with the original screen colors
used for the initial frame. */
- if (EQ (alist, Vdefault_frame_alist)
+ if (!f->default_face_done_p
&& 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];
+ init_frame_faces (f);
+ f->default_face_done_p = 1;
}
- orig_fg = FRAME_FOREGROUND_PIXEL (f);
- orig_bg = FRAME_BACKGROUND_PIXEL (f);
- frame_fg = Fcdr (Fassq (Qforeground_color, f->param_alist));
- frame_bg = Fcdr (Fassq (Qbackground_color, f->param_alist));
- /* frame_fg and frame_bg could be nil if, for example,
- f->param_alist is nil, e.g. if we are called from
- Fmake_terminal_frame. */
- if (NILP (frame_fg))
- frame_fg = build_string (unspecified_fg);
- if (NILP (frame_bg))
- frame_bg = build_string (unspecified_bg);
+ orig_fg = reverse ? FRAME_BACKGROUND_PIXEL (f) : FRAME_FOREGROUND_PIXEL (f);
+ orig_bg = reverse ? FRAME_FOREGROUND_PIXEL (f) : FRAME_BACKGROUND_PIXEL (f);
/* Extract parm names and values into those vectors. */
i = 0;
if (EQ (prop, Qreverse))
reverse = EQ (val, Qt);
+ else if (!menu_bar_lines_defined && EQ (prop, Qmenu_bar_lines))
+ menu_bar_lines_defined = 1;
}
- need_to_reverse = reverse && !was_reverse;
- if (termscript && need_to_reverse)
- fprintf (termscript, "<INVERSE-VIDEO>\n");
+ if (tty->termscript && reverse)
+ fprintf (tty->termscript, "<INVERSE-VIDEO>\n");
/* Now process the alist elements in reverse of specified order. */
for (i--; i >= 0; i--)
{
- Lisp_Object prop, val, frame;
+ Lisp_Object prop, val;
prop = parms[i];
val = values[i];
if (EQ (prop, Qforeground_color))
{
- unsigned long new_color = load_color (f, NULL, val, need_to_reverse
+ unsigned long new_color = load_color (f, NULL, val, reverse
? LFACE_BACKGROUND_INDEX
: LFACE_FOREGROUND_INDEX);
if (new_color != FACE_TTY_DEFAULT_COLOR
&& new_color != FACE_TTY_DEFAULT_FG_COLOR
&& new_color != FACE_TTY_DEFAULT_BG_COLOR)
{
- FRAME_FOREGROUND_PIXEL (f) = new_color;
- /* Make sure the foreground of the default face for this
- frame is changed as well. */
- XSETFRAME (frame, f);
- if (need_to_reverse)
+ if (!reverse)
{
- Finternal_set_lisp_face_attribute (Qdefault, QCbackground,
- val, frame);
- prop = Qbackground_color;
- bg_set = 1;
+ FRAME_FOREGROUND_PIXEL (f) = new_color;
+ /* Make sure the foreground of the default face for
+ this frame is changed as well. */
+ update_face_from_frame_parameter (f, Qforeground_color, val);
+ fg_set = 1;
+ if (tty->termscript)
+ fprintf (tty->termscript, "<FGCOLOR %lu>\n", new_color);
}
else
{
- Finternal_set_lisp_face_attribute (Qdefault, QCforeground,
- val, frame);
- fg_set = 1;
+ FRAME_BACKGROUND_PIXEL (f) = new_color;
+ update_face_from_frame_parameter (f, Qbackground_color, val);
+ bg_set = 1;
+ if (tty->termscript)
+ fprintf (tty->termscript, "<BGCOLOR %lu>\n", new_color);
}
redraw = 1;
- if (termscript)
- fprintf (termscript, "<FGCOLOR %lu>\n", new_color);
}
}
else if (EQ (prop, Qbackground_color))
{
- unsigned long new_color = load_color (f, NULL, val, need_to_reverse
+ unsigned long new_color = load_color (f, NULL, val, reverse
? LFACE_FOREGROUND_INDEX
: LFACE_BACKGROUND_INDEX);
if (new_color != FACE_TTY_DEFAULT_COLOR
&& new_color != FACE_TTY_DEFAULT_FG_COLOR
&& new_color != FACE_TTY_DEFAULT_BG_COLOR)
{
- FRAME_BACKGROUND_PIXEL (f) = new_color;
- /* Make sure the background of the default face for this
- frame is changed as well. */
- XSETFRAME (frame, f);
- if (need_to_reverse)
+ if (!reverse)
{
- Finternal_set_lisp_face_attribute (Qdefault, QCforeground,
- val, frame);
- prop = Qforeground_color;
- fg_set = 1;
+ FRAME_BACKGROUND_PIXEL (f) = new_color;
+ /* Make sure the background of the default face for
+ this frame is changed as well. */
+ bg_set = 1;
+ update_face_from_frame_parameter (f, Qbackground_color, val);
+ if (tty->termscript)
+ fprintf (tty->termscript, "<BGCOLOR %lu>\n", new_color);
}
else
{
- Finternal_set_lisp_face_attribute (Qdefault, QCbackground,
- val, frame);
- bg_set = 1;
+ FRAME_FOREGROUND_PIXEL (f) = new_color;
+ fg_set = 1;
+ update_face_from_frame_parameter (f, Qforeground_color, val);
+ if (tty->termscript)
+ fprintf (tty->termscript, "<FGCOLOR %lu>\n", new_color);
}
redraw = 1;
- if (termscript)
- fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
}
}
else if (EQ (prop, Qtitle))
{
x_set_title (f, val);
- if (termscript)
- fprintf (termscript, "<TITLE: %s>\n", SDATA (val));
+ if (tty->termscript)
+ fprintf (tty->termscript, "<TITLE: %s>\n", SDATA (val));
}
else if (EQ (prop, Qcursor_type))
{
IT_set_cursor_type (f, val);
- if (termscript)
- fprintf (termscript, "<CTYPE: %s>\n",
+ if (tty->termscript)
+ fprintf (tty->termscript, "<CTYPE: %s>\n",
EQ (val, Qbar) || EQ (val, Qhbar)
|| CONSP (val) && (EQ (XCAR (val), Qbar)
|| EQ (XCAR (val), Qhbar))
? "bar" : "box");
}
+ else if (EQ (prop, Qtty_type))
+ {
+ internal_terminal_init ();
+ if (tty->termscript)
+ fprintf (tty->termscript, "<TERM_INIT done, TTY_TYPE: %.*s>\n",
+ SBYTES (val), SDATA (val));
+ }
store_frame_param (f, prop, val);
}
+ /* If menu-bar-lines is neither in the frame parameters nor in
+ default-frame-alist, set it according to menu-bar-mode. */
+ if (!menu_bar_lines_defined)
+ {
+ store_frame_param (f, Qmenu_bar_lines,
+ NILP (Vmenu_bar_mode)
+ ? make_number (0) : make_number (1));
+ if (tty->termscript)
+ fprintf (tty->termscript, "<MENU BAR LINES DEFAULTED: %d\n",
+ !NILP (Vmenu_bar_mode));
+ }
+
/* If they specified "reverse", but not the colors, we need to swap
the current frame colors. */
- if (need_to_reverse)
+ if (reverse)
{
Lisp_Object frame;
if (!fg_set)
{
- XSETFRAME (frame, f);
- Finternal_set_lisp_face_attribute (Qdefault, QCforeground,
- tty_color_name (f, orig_bg),
- frame);
+ FRAME_FOREGROUND_PIXEL (f) = orig_bg;
+ update_face_from_frame_parameter (f, Qforeground_color,
+ tty_color_name (f, orig_bg));
redraw = 1;
}
if (!bg_set)
{
- XSETFRAME (frame, f);
- Finternal_set_lisp_face_attribute (Qdefault, QCbackground,
- tty_color_name (f, orig_fg),
- frame);
+ FRAME_BACKGROUND_PIXEL (f) = orig_fg;
+ update_face_from_frame_parameter (f, Qbackground_color,
+ tty_color_name (f, orig_fg));
redraw = 1;
}
}
/* Do we need the internal terminal? */
void
-internal_terminal_init ()
+internal_terminal_init (void)
{
+ static int init_needed = 1;
char *term = getenv ("TERM"), *colors;
struct frame *sf = SELECTED_FRAME();
+ struct tty_display_info *tty;
#ifdef HAVE_X_WINDOWS
if (!inhibit_window_system)
return;
#endif
+ /* If this is the initial terminal, we are done here. */
+ if (sf->output_method == output_initial)
+ return;
+
internal_terminal
= (!noninteractive) && term && !strcmp (term, "internal");
- if (getenv ("EMACSTEST"))
- termscript = fopen (getenv ("EMACSTEST"), "wt");
-
#ifndef HAVE_X_WINDOWS
if (!internal_terminal || inhibit_window_system)
{
return;
}
- Vwindow_system = intern ("pc");
- Vwindow_system_version = make_number (1);
+ tty = FRAME_TTY (sf);
+ current_kboard->Vwindow_system = Qpc;
sf->output_method = output_msdos_raw;
+ if (init_needed)
+ {
+ if (!tty->termscript && getenv ("EMACSTEST"))
+ tty->termscript = fopen (getenv ("EMACSTEST"), "wt");
+ if (tty->termscript)
+ {
+ time_t now = time (NULL);
+ struct tm *tnow = localtime (&now);
+ char tbuf[100];
- /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
- screen_old_address = 0;
+ strftime (tbuf, sizeof (tbuf) - 1, "%a %b %e %Y %H:%M:%S %Z", tnow);
+ fprintf (tty->termscript, "\nEmacs session started at %s\n", tbuf);
+ fprintf (tty->termscript, "=====================\n\n");
+ }
- /* Forget the stale screen colors as well. */
- initial_screen_colors[0] = initial_screen_colors[1] = -1;
+ Vinitial_window_system = Qpc;
+ Vwindow_system_version = make_number (23); /* RE Emacs version */
+ tty->terminal->type = output_msdos_raw;
- bzero (&the_only_x_display, sizeof the_only_x_display);
- FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = 7; /* White */
- FRAME_FOREGROUND_PIXEL (SELECTED_FRAME ()) = 0; /* Black */
- bright_bg ();
- colors = getenv ("EMACSCOLORS");
- if (colors && strlen (colors) >= 2)
- {
- /* 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)
- FRAME_FOREGROUND_PIXEL (SELECTED_FRAME ()) = colors[0];
- 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)
- FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = colors[1];
+ /* 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;
+
+ FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = 7; /* White */
+ FRAME_FOREGROUND_PIXEL (SELECTED_FRAME ()) = 0; /* Black */
+ bright_bg ();
+ colors = getenv ("EMACSCOLORS");
+ if (colors && strlen (colors) >= 2)
+ {
+ /* 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)
+ FRAME_FOREGROUND_PIXEL (SELECTED_FRAME ()) = colors[0];
+ 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)
+ FRAME_BACKGROUND_PIXEL (SELECTED_FRAME ()) = colors[1];
+ }
+ the_only_display_info.mouse_face_mouse_frame = NULL;
+ the_only_display_info.mouse_face_deferred_gc = 0;
+ the_only_display_info.mouse_face_beg_row =
+ the_only_display_info.mouse_face_beg_col = -1;
+ the_only_display_info.mouse_face_end_row =
+ the_only_display_info.mouse_face_end_col = -1;
+ the_only_display_info.mouse_face_face_id = DEFAULT_FACE_ID;
+ the_only_display_info.mouse_face_window = Qnil;
+ the_only_display_info.mouse_face_mouse_x =
+ the_only_display_info.mouse_face_mouse_y = 0;
+ the_only_display_info.mouse_face_defer = 0;
+ the_only_display_info.mouse_face_hidden = 0;
+
+ if (have_mouse) /* detected in dos_ttraw, which see */
+ {
+ have_mouse = 1; /* enable mouse */
+ mouse_visible = 0;
+ mouse_setup_buttons (mouse_button_count);
+ tty->terminal->mouse_position_hook = &mouse_get_pos;
+ mouse_init ();
+ }
+
+ if (tty->termscript && screen_size)
+ fprintf (tty->termscript, "<SCREEN SAVED (dimensions=%dx%d)>\n",
+ screen_size_X, screen_size_Y);
+
+ init_frame_faces (sf);
+ init_needed = 0;
}
- the_only_x_display.font = (XFontStruct *)1; /* must *not* be zero */
- the_only_x_display.display_info.mouse_face_mouse_frame = NULL;
- the_only_x_display.display_info.mouse_face_deferred_gc = 0;
- the_only_x_display.display_info.mouse_face_beg_row =
- the_only_x_display.display_info.mouse_face_beg_col = -1;
- the_only_x_display.display_info.mouse_face_end_row =
- the_only_x_display.display_info.mouse_face_end_col = -1;
- the_only_x_display.display_info.mouse_face_face_id = DEFAULT_FACE_ID;
- the_only_x_display.display_info.mouse_face_window = Qnil;
- the_only_x_display.display_info.mouse_face_mouse_x =
- the_only_x_display.display_info.mouse_face_mouse_y = 0;
- the_only_x_display.display_info.mouse_face_defer = 0;
- the_only_x_display.display_info.mouse_face_hidden = 0;
-
- 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;
- clear_end_of_line_hook = IT_clear_end_of_line;
- clear_frame_hook = IT_clear_screen;
- update_begin_hook = IT_update_begin;
- update_end_hook = IT_update_end;
- frame_up_to_date_hook = IT_frame_up_to_date;
-
- /* 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;
- TTY_CHAR_INS_DEL_OK (CURTTY ()) = 0;
#endif
}
-dos_get_saved_screen (screen, rows, cols)
- char **screen;
- int *rows;
- int *cols;
+void
+initialize_msdos_display (struct terminal *term)
+{
+ term->rif = 0; /* we don't support window-based display */
+ term->cursor_to_hook = term->raw_cursor_to_hook = IT_cursor_to;
+ term->clear_to_end_hook = IT_clear_to_end;
+ term->clear_frame_hook = IT_clear_screen;
+ term->clear_end_of_line_hook = IT_clear_end_of_line;
+ term->ins_del_lines_hook = 0;
+ term->insert_glyphs_hook = IT_insert_glyphs;
+ term->write_glyphs_hook = IT_write_glyphs;
+ term->delete_glyphs_hook = IT_delete_glyphs;
+ term->ring_bell_hook = IT_ring_bell;
+ term->reset_terminal_modes_hook = IT_reset_terminal_modes;
+ term->set_terminal_modes_hook = IT_set_terminal_modes;
+ term->set_terminal_window_hook = IT_set_terminal_window;
+ term->update_begin_hook = IT_update_begin;
+ term->update_end_hook = IT_update_end;
+ term->frame_up_to_date_hook = IT_frame_up_to_date;
+ term->mouse_position_hook = 0; /* set later by dos_ttraw */
+ term->frame_rehighlight_hook = 0;
+ term->frame_raise_lower_hook = 0;
+ term->set_vertical_scroll_bar_hook = 0;
+ term->condemn_scroll_bars_hook = 0;
+ term->redeem_scroll_bar_hook = 0;
+ term->judge_scroll_bars_hook = 0;
+ term->read_socket_hook = &tty_read_avail_input; /* from keyboard.c */
+}
+
+int
+dos_get_saved_screen (char **screen, int *rows, int *cols)
{
#ifndef HAVE_X_WINDOWS
*screen = startup_screen_buffer;
static int international_keyboard;
int
-dos_set_keyboard (code, always)
- int code;
- int always;
+dos_set_keyboard (int code, int always)
{
int i;
_go32_dpmi_registers regs;
#define HYPER_P 0x8000 /* pseudo */
static int
-dos_get_modifiers (keymask)
- int *keymask;
+dos_get_modifiers (int *keymask)
{
union REGS regs;
int mask, modifiers = 0;
#define NUM_RECENT_DOSKEYS (100)
int recent_doskeys_index; /* Index for storing next element into recent_doskeys */
int total_doskeys; /* Total number of elements stored into recent_doskeys */
-Lisp_Object recent_doskeys; /* A vector, holding the last 100 keystrokes */
+Lisp_Object recent_doskeys; /* A vector, holding the last 100 keystrokes */
DEFUN ("recent-doskeys", Frecent_doskeys, Srecent_doskeys, 0, 0, 0,
doc: /* Return vector of last 100 keyboard input values seen in dos_rawgetc.
else
{
val = Fvector (NUM_RECENT_DOSKEYS, keys);
- bcopy (keys + recent_doskeys_index,
- XVECTOR (val)->contents,
- (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
- bcopy (keys,
- XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
- recent_doskeys_index * sizeof (Lisp_Object));
+ memcpy (XVECTOR (val)->contents, keys + recent_doskeys_index,
+ (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
+ memcpy (XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
+ keys, recent_doskeys_index * sizeof (Lisp_Object));
return val;
}
}
/* Get a char from keyboard. Function keys are put into the event queue. */
static int
-dos_rawgetc ()
+dos_rawgetc (void)
{
struct input_event event;
union REGS regs;
- struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (SELECTED_FRAME());
+ struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (SELECTED_FRAME());
EVENT_INIT (event);
#ifndef HAVE_X_WINDOWS
static int prev_get_char = -1;
/* Return 1 if a key is ready to be read without suspending execution. */
-
-dos_keysns ()
+int
+dos_keysns (void)
{
if (prev_get_char != -1)
return 1;
}
/* Read a key. Return -1 if no key is ready. */
-
-dos_keyread ()
+int
+dos_keyread (void)
{
if (prev_get_char != -1)
{
static int menu_help_paneno, menu_help_itemno;
static XMenu *
-IT_menu_create ()
+IT_menu_create (void)
{
XMenu *menu;
/* Display MENU at (X,Y) using FACES. */
+#define BUILD_CHAR_GLYPH(GLYPH, CODE, FACE_ID, PADDING_P) \
+ do \
+ { \
+ (GLYPH).type = CHAR_GLYPH; \
+ SET_CHAR_GLYPH ((GLYPH), CODE, FACE_ID, PADDING_P); \
+ (GLYPH).charpos = -1; \
+ } \
+ while (0)
+
static void
IT_menu_display (XMenu *menu, int y, int x, int pn, int *faces, int disp_help)
{
int i, j, face, width, mx, my, enabled, mousehere, row, col;
struct glyph *text, *p;
- char *q;
+ const unsigned char *q;
struct frame *sf = SELECTED_FRAME();
menu_help_message = NULL;
width = menu->width;
- text = (struct glyph *) xmalloc ((width + 2) * sizeof (struct glyph));
+ /* We multiply width by 2 to account for possible control characters.
+ FIXME: cater to non-ASCII characters in menus. */
+ text = (struct glyph *) xmalloc ((width * 2 + 2) * sizeof (struct glyph));
ScreenGetCursor (&row, &col);
mouse_get_xy (&mx, &my);
IT_update_begin (sf);
{
int max_width = width + 2;
- IT_cursor_to (y + i, x);
+ IT_cursor_to (sf, y + i, x);
enabled
= (!menu->submenu[i] && menu->panenumber[i]) || (menu->submenu[i]);
- mousehere = (y + i == my && x <= mx && mx < x + width + 2);
+ mousehere = (y + i == my && x <= mx && mx < x + max_width);
face = faces[enabled + mousehere * 2];
/* The following if clause means that we display the menu help
strings even if the menu item is currently disabled. */
menu_help_itemno = i;
}
p = text;
- SET_CHAR_GLYPH (*p, ' ', face, 0);
+ BUILD_CHAR_GLYPH (*p, ' ', face, 0);
p++;
for (j = 0, q = menu->text[i]; *q; j++)
{
- if (*q > 26)
+ unsigned c = STRING_CHAR_ADVANCE (q);
+
+ if (c > 26)
{
- SET_CHAR_GLYPH (*p, *q++, face, 0);
+ BUILD_CHAR_GLYPH (*p, c, face, 0);
p++;
}
else /* make '^x' */
{
- SET_CHAR_GLYPH (*p, '^', face, 0);
+ BUILD_CHAR_GLYPH (*p, '^', face, 0);
p++;
j++;
- SET_CHAR_GLYPH (*p, *q++ + 64, face, 0);
+ BUILD_CHAR_GLYPH (*p, c + 64, face, 0);
p++;
}
}
text[max_width - 1].u.ch = '$'; /* indicate it's truncated */
}
for (; j < max_width - 2; j++, p++)
- SET_CHAR_GLYPH (*p, ' ', face, 0);
+ BUILD_CHAR_GLYPH (*p, ' ', face, 0);
- SET_CHAR_GLYPH (*p, menu->submenu[i] ? 16 : ' ', face, 0);
+ /* 16 is the character code of a character that on DOS terminal
+ produces a nice-looking right-pointing arrow glyph. */
+ BUILD_CHAR_GLYPH (*p, menu->submenu[i] ? 16 : ' ', face, 0);
p++;
- IT_write_glyphs (text, max_width);
+ IT_write_glyphs (sf, text, max_width);
}
IT_update_end (sf);
- IT_cursor_to (row, col);
+ IT_cursor_to (sf, row, col);
xfree (text);
}
\f
/* Report availability of menus. */
int
-have_menus_p () { return 1; }
+have_menus_p (void) { return 1; }
/* Create a brand new menu structure. */
/* Destructively turn backslashes into slashes. */
void
-dostounix_filename (p)
- register char *p;
+dostounix_filename (char *p)
{
msdos_downcase_filename (p);
/* Destructively turn slashes into backslashes. */
void
-unixtodos_filename (p)
- register char *p;
+unixtodos_filename (char *p)
{
if (p[1] == ':' && *p >= 'A' && *p <= 'Z')
{
/* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
int
-getdefdir (drive, dst)
- int drive;
- char *dst;
+getdefdir (int drive, char *dst)
{
char in_path[4], *p = in_path, e = errno;
/* Remove all CR's that are followed by a LF. */
int
-crlf_to_lf (n, buf)
- register int n;
- register unsigned char *buf;
+crlf_to_lf (int n, unsigned char *buf)
{
unsigned char *np = buf, *startp = buf, *endp = buf + n;
return np - startp;
}
-#if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
-
-/* In DJGPP v2.0, library `write' can call `malloc', which might
- cause relocation of the buffer whose address we get in ADDR.
- Here is a version of `write' that avoids calling `malloc',
- to serve us until such time as the library is fixed.
- Actually, what we define here is called `__write', because
- `write' is a stub that just jmp's to `__write' (to be
- POSIXLY-correct with respect to the global name-space). */
-
-#include <io.h> /* for _write */
-#include <libc/dosio.h> /* for __file_handle_modes[] */
-
-static char xbuf[64 * 1024]; /* DOS cannot write more in one chunk */
-
-#define XBUF_END (xbuf + sizeof (xbuf) - 1)
-
-int
-__write (int handle, const void *buffer, size_t count)
-{
- if (count == 0)
- return 0;
-
- if(__file_handle_modes[handle] & O_BINARY)
- return _write (handle, buffer, count);
- else
- {
- char *xbp = xbuf;
- const char *bp = buffer;
- int total_written = 0;
- int nmoved = 0, ncr = 0;
-
- while (count)
- {
- /* The next test makes sure there's space for at least 2 more
- characters in xbuf[], so both CR and LF can be put there. */
- if (xbp < XBUF_END)
- {
- if (*bp == '\n')
- {
- ncr++;
- *xbp++ = '\r';
- }
- *xbp++ = *bp++;
- nmoved++;
- count--;
- }
- if (xbp >= XBUF_END || !count)
- {
- size_t to_write = nmoved + ncr;
- int written = _write (handle, xbuf, to_write);
-
- if (written == -1)
- return -1;
- else
- total_written += nmoved; /* CRs aren't counted in ret value */
-
- /* If some, but not all were written (disk full?), return
- an estimate of the total written bytes not counting CRs. */
- if (written < to_write)
- return total_written - (to_write - written) * nmoved/to_write;
-
- nmoved = 0;
- ncr = 0;
- xbp = xbuf;
- }
- }
- return total_written;
- }
-}
-
-/* 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,
- doc: /* Return non-nil if long file names are supported on MSDOS. */)
+ doc: /* Return non-nil if long file names are supported on MS-DOS. */)
()
{
return (_USE_LFN ? Qt : Qnil);
/* Convert alphabetic characters in a filename to lower-case. */
void
-msdos_downcase_filename (p)
- register unsigned char *p;
+msdos_downcase_filename (unsigned char *p)
{
/* Always lower-case drive letters a-z, even if the filesystem
preserves case in filenames.
static char emacsroot[MAXPATHLEN];
char *
-rootrelativepath (rel)
- char *rel;
+rootrelativepath (char *rel)
{
static char result[MAXPATHLEN + 10];
break if one or more of these are missing. */
void
-init_environment (argc, argv, skip_args)
- int argc;
- char **argv;
- int skip_args;
+init_environment (int argc, char **argv, int skip_args)
{
char *s, *t, *root;
int len, i;
static int break_stat; /* BREAK check mode status. */
static int stdin_stat; /* stdin IOCTL status. */
-#if __DJGPP__ < 2
-
-/* These must be global. */
-static _go32_dpmi_seginfo ctrl_break_vector;
-static _go32_dpmi_registers ctrl_break_regs;
-static int ctrlbreakinstalled = 0;
-
-/* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
-
-void
-ctrl_break_func (regs)
- _go32_dpmi_registers *regs;
-{
- Vquit_flag = Qt;
-}
-
-void
-install_ctrl_break_check ()
-{
- if (!ctrlbreakinstalled)
- {
- /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
- was compiler with Djgpp 1.11 maintenance level 5 or later! */
- ctrlbreakinstalled = 1;
- ctrl_break_vector.pm_offset = (int) ctrl_break_func;
- _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector,
- &ctrl_break_regs);
- _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector);
- }
-}
-
-#endif /* __DJGPP__ < 2 */
-
/* Turn off Dos' Ctrl-C checking and inhibit interpretation of
control chars by DOS. Determine the keyboard type. */
int
-dos_ttraw ()
+dos_ttraw (struct tty_display_info *tty)
{
union REGS inregs, outregs;
static int first_time = 1;
+ /* If we are called for the initial terminal, it's too early to do
+ anything, and termscript isn't set up. */
+ if (tty->terminal->type == output_initial)
+ return;
+
break_stat = getcbrk ();
setcbrk (0);
-#if __DJGPP__ < 2
- install_ctrl_break_check ();
-#endif
if (first_time)
{
have_mouse = 0;
- if (internal_terminal
+ if (1
#ifdef HAVE_X_WINDOWS
&& inhibit_window_system
#endif
int86 (0x33, &inregs, &outregs);
have_mouse = (outregs.x.ax & 0xffff) == 0xffff;
}
-
if (have_mouse)
- {
- have_mouse = 1; /* enable mouse */
- mouse_visible = 0;
- mouse_setup_buttons (outregs.x.bx);
- mouse_position_hook = &mouse_get_pos;
- mouse_init ();
- }
+ mouse_button_count = outregs.x.bx;
#ifndef HAVE_X_WINDOWS
-#if __DJGPP__ >= 2
/* Save the cursor shape used outside Emacs. */
outside_cursor = _farpeekw (_dos_ds, 0x460);
-#endif
#endif
}
first_time = 0;
-#if __DJGPP__ >= 2
-
stdin_stat = setmode (fileno (stdin), O_BINARY);
return (stdin_stat != -1);
}
else
return (setmode (fileno (stdin), O_BINARY) != -1);
-
-#else /* __DJGPP__ < 2 */
-
- }
-
- /* I think it is wrong to overwrite `stdin_stat' every time
- but the first one this function is called, but I don't
- want to change the way it used to work in v1.x.--EZ */
-
- inregs.x.ax = 0x4400; /* Get IOCTL status. */
- inregs.x.bx = 0x00; /* 0 = stdin. */
- intdos (&inregs, &outregs);
- stdin_stat = outregs.h.dl;
-
- inregs.x.dx = stdin_stat | 0x0020; /* raw mode */
- inregs.x.ax = 0x4401; /* Set IOCTL status */
- intdos (&inregs, &outregs);
- return !outregs.x.cflag;
-
-#endif /* __DJGPP__ < 2 */
}
/* Restore status of standard input and Ctrl-C checking. */
int
-dos_ttcooked ()
+dos_ttcooked (void)
{
union REGS inregs, outregs;
setcbrk (break_stat);
mouse_off ();
-#if __DJGPP__ >= 2
-
#ifndef HAVE_X_WINDOWS
/* Restore the cursor shape we found on startup. */
if (outside_cursor)
#endif
return (setmode (fileno (stdin), stdin_stat) != -1);
-
-#else /* not __DJGPP__ >= 2 */
-
- inregs.x.ax = 0x4401; /* Set IOCTL status. */
- inregs.x.bx = 0x00; /* 0 = stdin. */
- inregs.x.dx = stdin_stat;
- intdos (&inregs, &outregs);
- return !outregs.x.cflag;
-
-#endif /* not __DJGPP__ >= 2 */
}
\f
file TEMPOUT and stderr to TEMPERR. */
int
-run_msdos_command (argv, working_dir, tempin, tempout, temperr, envv)
- unsigned char **argv;
- const char *working_dir;
- int tempin, tempout, temperr;
- char **envv;
+run_msdos_command (unsigned char **argv, const char *working_dir,
+ int tempin, int tempout, int temperr, char **envv)
{
char *saveargv1, *saveargv2, *lowcase_argv0, *pa, *pl;
char oldwd[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS. */
if (have_mouse > 0)
mouse_get_xy (&x, &y);
- dos_ttcooked (); /* do it here while 0 = stdin */
+ if (!noninteractive)
+ dos_ttcooked (); /* do it here while 0 = stdin */
dup2 (tempin, 0);
dup2 (tempout, 1);
dup2 (temperr, 2);
-#if __DJGPP__ > 1
-
if (msshell && !argv[3])
{
/* MS-DOS native shells are too restrictive. For starters, they
result = 0; /* emulate Unixy shell behavior with empty cmd line */
}
else
-
-#endif /* __DJGPP__ > 1 */
-
- result = spawnve (P_WAIT, argv[0], argv, envv);
+ result = spawnve (P_WAIT, argv[0], argv, envv);
dup2 (inbak, 0);
dup2 (outbak, 1);
emacs_close (outbak);
emacs_close (errbak);
- dos_ttraw ();
+ if (!noninteractive)
+ dos_ttraw (CURTTY ());
if (have_mouse > 0)
{
mouse_init ();
/* 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 ();
+ if (!noninteractive)
+ bright_bg ();
done:
chdir (oldwd);
}
void
-croak (badfunc)
- char *badfunc;
+croak (char *badfunc)
{
fprintf (stderr, "%s not yet implemented\r\n", badfunc);
reset_all_sys_modes ();
exit (1);
}
\f
-#if __DJGPP__ < 2
-
-/* ------------------------- Compatibility functions -------------------
- * gethostname
- * gettimeofday
- */
-
-/* Hostnames for a pc are not really funny,
- but they are used in change log so we emulate the best we can. */
-
-gethostname (p, size)
- char *p;
- int size;
-{
- char *q = egetenv ("HOSTNAME");
-
- if (!q) q = "pc";
- strcpy (p, q);
- return 0;
-}
-
-/* When time zones are set from Ms-Dos too many C-libraries are playing
- tricks with time values. We solve this by defining our own version
- of `gettimeofday' bypassing GO32. Our version needs to be initialized
- once and after each call to `tzset' with TZ changed. That is
- accomplished by aliasing tzset to init_gettimeofday. */
-
-static struct tm time_rec;
-
-int
-gettimeofday (struct timeval *tp, struct timezone *tzp)
-{
- if (tp)
- {
- struct time t;
- struct tm tm;
-
- gettime (&t);
- if (t.ti_hour < time_rec.tm_hour) /* midnight wrap */
- {
- struct date d;
- getdate (&d);
- time_rec.tm_year = d.da_year - 1900;
- time_rec.tm_mon = d.da_mon - 1;
- time_rec.tm_mday = d.da_day;
- }
-
- time_rec.tm_hour = t.ti_hour;
- time_rec.tm_min = t.ti_min;
- time_rec.tm_sec = t.ti_sec;
-
- tm = time_rec;
- tm.tm_gmtoff = dos_timezone_offset;
-
- tp->tv_sec = mktime (&tm); /* may modify tm */
- tp->tv_usec = t.ti_hund * (1000000 / 100);
- }
- /* Ignore tzp; it's obsolescent. */
- return 0;
-}
-
-#endif /* __DJGPP__ < 2 */
-
/*
- * A list of unimplemented functions that we silently ignore.
+ * A few unimplemented functions that we silently ignore.
*/
-
-#if __DJGPP__ < 2
-unsigned alarm (s) unsigned s; {}
-fork () { return 0; }
-int kill (x, y) int x, y; { return -1; }
-nice (p) int p; {}
-void volatile pause () {}
-sigsetmask (x) int x; { return 0; }
-sigblock (mask) int mask; { return 0; }
-#endif
-
-void request_sigio (void) {}
-setpgrp () {return 0; }
-setpriority (x,y,z) int x,y,z; { return 0; }
-void unrequest_sigio (void) {}
-
-#if __DJGPP__ > 1
-#if __DJGPP_MINOR__ < 2
-
-#ifdef POSIX_SIGNALS
+int setpgrp (void) {return 0; }
+int setpriority (int x, int y, int z) { return 0; }
+\f
+#if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
/* Augment DJGPP library POSIX signal functions. This is needed
as of DJGPP v2.01, but might be in the library in later releases. */
static sigset_t current_mask;
/* Which signals are pending (initially none). */
-static sigset_t pending_signals;
+static sigset_t msdos_pending_signals;
/* Previous handlers to restore when the blocked signals are unblocked. */
typedef void (*sighandler_t)(int);
/* A signal handler which just records that a signal occurred
(it will be raised later, if and when the signal is unblocked). */
static void
-sig_suspender (signo)
- int signo;
+sig_suspender (int signo)
{
- sigaddset (&pending_signals, signo);
+ sigaddset (&msdos_pending_signals, signo);
}
int
-sigprocmask (how, new_set, old_set)
- int how;
- const sigset_t *new_set;
- sigset_t *old_set;
+sigprocmask (int how, const sigset_t *new_set, sigset_t *old_set)
{
int signo;
sigset_t new_mask;
if (sigprocmask_count != __bss_count)
{
sigprocmask_count = __bss_count;
- sigemptyset (&pending_signals);
+ sigemptyset (&msdos_pending_signals);
sigemptyset (¤t_mask);
for (signo = 0; signo < 320; signo++)
prev_handlers[signo] = SIG_ERR;
signal (signo, prev_handlers[signo]);
prev_handlers[signo] = SIG_ERR;
}
- if (sigismember (&pending_signals, signo))
+ if (sigismember (&msdos_pending_signals, signo))
{
- sigdelset (&pending_signals, signo);
+ sigdelset (&msdos_pending_signals, signo);
raise (signo);
}
}
return 0;
}
-#else /* not POSIX_SIGNALS */
-
-sigsetmask (x) int x; { return 0; }
-sigblock (mask) int mask; { return 0; }
-
-#endif /* not POSIX_SIGNALS */
#endif /* not __DJGPP_MINOR__ < 2 */
-#endif /* __DJGPP__ > 1 */
#ifndef HAVE_SELECT
#include "sysselect.h"
/* We don't have to call timer_check here
because wait_reading_process_output takes care of that. */
int
-sys_select (nfds, rfds, wfds, efds, timeout)
- int nfds;
- SELECT_TYPE *rfds, *wfds, *efds;
- EMACS_TIME *timeout;
+sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
+ EMACS_TIME *timeout)
{
int check_input;
struct time t;
#ifdef chdir
#undef chdir
-extern int chdir ();
+extern int chdir (const char *);
int
-sys_chdir (path)
- const char* path;
+sys_chdir (const char *path)
{
int len = strlen (path);
char *tmp = (char *)path;
extern void tzset (void);
void
-init_gettimeofday ()
+init_gettimeofday (void)
{
time_t ltm, gtm;
struct tm *lstm;
#ifdef abort
#undef abort
void
-dos_abort (file, line)
- char *file;
- int line;
+dos_abort (char *file, int line)
{
char buffer1[200], buffer2[400];
int i, j;
}
#else
void
-abort ()
+abort (void)
{
dos_ttcooked ();
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);
#else /* __DJGPP_MINOR__ >= 2 */
raise (SIGABRT);
#endif /* __DJGPP_MINOR__ >= 2 */
-#endif
exit (2);
}
#endif
static int delete_exited_processes;
#endif
-syms_of_msdos ()
+void
+syms_of_msdos (void)
{
recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
staticpro (&recent_doskeys);
DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph,
doc: /* *Glyph to display instead of chars not supported by current codepage.
-This variable is used only by MSDOS terminals. */);
+This variable is used only by MS-DOS terminals. */);
Vdos_unsupported_char_glyph = make_number ('\177');
#endif
HCoop / bpt / emacs.git / blobdiff