-/* $OpenBSD: lib_color.c,v 1.5 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_color.c,v 1.6 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h>
#include <tic.h>
-MODULE_ID("$From: lib_color.c,v 1.42 2000/01/01 16:42:37 tom Exp $")
+MODULE_ID("$From: lib_color.c,v 1.45 2000/02/27 00:20:31 tom Exp $")
/*
* These should be screen structure members. They need to be globals for
- * hystorical reasons. So we assign them in start_color() and also in
+ * historical reasons. So we assign them in start_color() and also in
* set_term()'s screen-switching logic.
*/
int COLOR_PAIRS = 0;
static int
default_fg(void)
{
- return (SP->_default_fg >= 0) ? SP->_default_fg : COLOR_WHITE;
+ return (SP->_default_fg != C_MASK) ? SP->_default_fg : COLOR_WHITE;
}
static int
default_bg(void)
{
- return (SP->_default_bg >= 0) ? SP->_default_bg : COLOR_BLACK;
+ return (SP->_default_bg != C_MASK) ? SP->_default_bg : COLOR_BLACK;
}
#else
#define default_fg() COLOR_WHITE
!SP->_default_color ||
#endif
!set_original_colors()) {
- set_foreground_color(default_fg(), outc);
- set_background_color(default_bg(), outc);
+ fg = default_fg();
+ bg = default_bg();
+ } else {
+ fg = C_MASK;
+ bg = C_MASK;
}
} else {
if (set_color_pair) {
TPUTS_TRACE("set_color_pair");
tputs(tparm(set_color_pair, pair), 1, outc);
+ return;
} else {
pair_content(pair, &fg, &bg);
- if (reverse) {
- short xx = fg;
- fg = bg;
- bg = xx;
+#ifdef NCURSES_EXT_FUNCS
+ if (SP->_default_color) {
+ if (fg == C_MASK)
+ fg = SP->_default_fg;
+ if (bg == C_MASK)
+ bg = SP->_default_bg;
}
+#endif
+ }
+ }
- T(("setting colors: pair = %d, fg = %d, bg = %d", pair, fg, bg));
-
- if (fg == C_MASK || bg == C_MASK) {
- if (set_original_colors() != TRUE) {
- if (fg == C_MASK)
- set_foreground_color(default_fg(), outc);
- if (bg == C_MASK)
- set_background_color(default_bg(), outc);
- }
- }
- if (fg != C_MASK) {
- set_foreground_color(fg, outc);
- }
- if (bg != C_MASK) {
- set_background_color(bg, outc);
- }
+ if (fg == C_MASK || bg == C_MASK) {
+ if (set_original_colors() != TRUE) {
+ if (fg == C_MASK)
+ fg = default_fg();
+ if (bg == C_MASK)
+ bg = default_bg();
}
}
+
+ if (reverse) {
+ short xx = fg;
+ fg = bg;
+ bg = xx;
+ }
+
+ T(("setting colors: pair = %d, fg = %d, bg = %d", pair, fg, bg));
+
+ if (fg != C_MASK) {
+ set_foreground_color(fg, outc);
+ }
+ if (bg != C_MASK) {
+ set_background_color(bg, outc);
+ }
}
-/* $OpenBSD: lib_dft_fgbg.c,v 1.2 1999/11/28 17:49:53 millert Exp $ */
+/* $OpenBSD: lib_dft_fgbg.c,v 1.3 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998,1999 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
/****************************************************************************
* Author: Thomas E. Dickey <dickey@clark.net> 1997,1999 *
****************************************************************************/
+
#include <curses.priv.h>
#include <term.h>
-MODULE_ID("$From: lib_dft_fgbg.c,v 1.7 1999/11/14 01:22:11 tom Exp $")
+MODULE_ID("$From: lib_dft_fgbg.c,v 1.8 2000/02/19 23:57:40 tom Exp $")
/*
* Modify the behavior of color-pair 0 so that the library doesn't assume that
int
use_default_colors(void)
{
- T((T_CALLED("use_default_colors()")));
- returnCode(assume_default_colors(C_MASK, C_MASK));
+ T((T_CALLED("use_default_colors()")));
+ returnCode(assume_default_colors(C_MASK, C_MASK));
}
/*
int
assume_default_colors(int fg, int bg)
{
- T((T_CALLED("assume_default_colors(%d,%d)"), fg, bg));
+ T((T_CALLED("assume_default_colors(%d,%d)"), fg, bg));
- if (!orig_pair && !orig_colors)
- returnCode(ERR);
+ if (!orig_pair && !orig_colors)
+ returnCode(ERR);
- if (initialize_pair) /* don't know how to handle this */
- returnCode(ERR);
+ if (initialize_pair) /* don't know how to handle this */
+ returnCode(ERR);
- SP->_default_color = (fg != COLOR_WHITE) || (bg != COLOR_BLACK);
- SP->_default_fg = fg;
- SP->_default_bg = bg;
- if (SP->_color_pairs != 0)
- SP->_color_pairs[0] = PAIR_OF(fg, bg);
- returnCode(OK);
+ SP->_default_color = (fg != COLOR_WHITE) || (bg != COLOR_BLACK);
+ SP->_default_fg = (fg >= 0) ? (fg & C_MASK) : C_MASK;
+ SP->_default_bg = (bg >= 0) ? (bg & C_MASK) : C_MASK;
+ if (SP->_color_pairs != 0)
+ SP->_color_pairs[0] = PAIR_OF(fg, bg);
+ returnCode(OK);
}
-/* $OpenBSD: lib_getch.c,v 1.3 2000/01/23 04:57:41 millert Exp $ */
+/* $OpenBSD: lib_getch.c,v 1.4 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <curses.priv.h>
-MODULE_ID("$From: lib_getch.c,v 1.44 2000/01/17 19:58:18 tom Exp $")
+MODULE_ID("$From: lib_getch.c,v 1.46 2000/02/20 01:21:33 tom Exp $")
#include <fifo_defs.h>
-int ESCDELAY = 1000; /* max interval betw. chars in funkeys, in millisecs */
+int ESCDELAY = 1000; /* max interval betw. chars in funkeys, in millisecs */
#ifdef USE_EMX_MOUSE
# include <sys/select.h>
static int
kbd_mouse_read(unsigned char *p)
{
-fd_set fdset;
-int nums = SP->_ifd+1;
-
- for (;;) {
- FD_ZERO(&fdset);
- FD_SET(SP->_ifd, &fdset);
- if (SP->_checkfd >= 0) {
- FD_SET(SP->_checkfd, &fdset);
- if (SP->_checkfd >= nums)
- nums = SP->_checkfd + 1;
- }
- if (SP->_mouse_fd >= 0) {
- FD_SET(SP->_mouse_fd, &fdset);
- if (SP->_mouse_fd >= nums)
- nums = SP->_mouse_fd + 1;
- }
- if (select(nums, &fdset, NULL, NULL, NULL) >= 0) {
- int n;
-
- if (SP->_mouse_fd >= 0
- && FD_ISSET(SP->_mouse_fd, &fdset)) { /* Prefer mouse */
- n = read(SP->_mouse_fd, p, 1);
- } else {
- n = read(SP->_ifd, p, 1);
- }
- return n;
- }
- if (errno != EINTR) {
- return -1;
- }
+ fd_set fdset;
+ int nums = SP->_ifd + 1;
+
+ for (;;) {
+ FD_ZERO(&fdset);
+ FD_SET(SP->_ifd, &fdset);
+ if (SP->_checkfd >= 0) {
+ FD_SET(SP->_checkfd, &fdset);
+ if (SP->_checkfd >= nums)
+ nums = SP->_checkfd + 1;
}
+ if (SP->_mouse_fd >= 0) {
+ FD_SET(SP->_mouse_fd, &fdset);
+ if (SP->_mouse_fd >= nums)
+ nums = SP->_mouse_fd + 1;
+ }
+ if (select(nums, &fdset, NULL, NULL, NULL) >= 0) {
+ int n;
+
+ if (SP->_mouse_fd >= 0
+ && FD_ISSET(SP->_mouse_fd, &fdset)) { /* Prefer mouse */
+ n = read(SP->_mouse_fd, p, 1);
+ } else {
+ n = read(SP->_ifd, p, 1);
+ }
+ return n;
+ }
+ if (errno != EINTR) {
+ return -1;
+ }
+ }
}
-#endif /* USE_EMX_MOUSE */
+#endif /* USE_EMX_MOUSE */
-static inline int fifo_peek(void)
+static inline int
+fifo_peek(void)
{
- int ch = SP->_fifo[peek];
- T(("peeking at %d", peek));
+ int ch = SP->_fifo[peek];
+ T(("peeking at %d", peek));
- p_inc();
- return ch;
+ p_inc();
+ return ch;
}
-
-static inline int fifo_pull(void)
+static inline int
+fifo_pull(void)
{
-int ch;
- ch = SP->_fifo[head];
- T(("pulling %d from %d", ch, head));
+ int ch;
+ ch = SP->_fifo[head];
+ T(("pulling %d from %d", ch, head));
- if (peek == head)
- {
- h_inc();
- peek = head;
- }
- else
- h_inc();
+ if (peek == head) {
+ h_inc();
+ peek = head;
+ } else
+ h_inc();
#ifdef TRACE
- if (_nc_tracing & TRACE_IEVENT) _nc_fifo_dump();
+ if (_nc_tracing & TRACE_IEVENT)
+ _nc_fifo_dump();
#endif
- return ch;
+ return ch;
}
-static inline int fifo_push(void)
+static inline int
+fifo_push(void)
{
-int n;
-unsigned int ch;
+ int n;
+ unsigned int ch;
- if (tail == -1) return ERR;
+ if (tail == -1)
+ return ERR;
#ifdef HIDE_EINTR
-again:
- errno = 0;
+ again:
+ errno = 0;
#endif
#if USE_GPM_SUPPORT
- if ((SP->_mouse_fd >= 0)
- && (_nc_timed_wait(3, -1, (int *)0) & 2))
- {
- SP->_mouse_event(SP);
- ch = KEY_MOUSE;
- n = 1;
- } else
+ if ((SP->_mouse_fd >= 0)
+ && (_nc_timed_wait(3, -1, (int *) 0) & 2)) {
+ SP->_mouse_event(SP);
+ ch = KEY_MOUSE;
+ n = 1;
+ } else
#endif
- {
- unsigned char c2=0;
+ {
+ unsigned char c2 = 0;
#ifdef USE_EMX_MOUSE
- n = kbd_mouse_read(&c2);
+ n = kbd_mouse_read(&c2);
#else
- n = read(SP->_ifd, &c2, 1);
+ n = read(SP->_ifd, &c2, 1);
#endif
- ch = c2 & 0xff;
- }
+ ch = c2 & 0xff;
+ }
#ifdef HIDE_EINTR
- /*
- * Under System V curses with non-restarting signals, getch() returns
- * with value ERR when a handled signal keeps it from completing.
- * If signals restart system calls, OTOH, the signal is invisible
- * except to its handler.
- *
- * We don't want this difference to show. This piece of code
- * tries to make it look like we always have restarting signals.
- */
- if (n <= 0 && errno == EINTR)
- goto again;
+ /*
+ * Under System V curses with non-restarting signals, getch() returns
+ * with value ERR when a handled signal keeps it from completing.
+ * If signals restart system calls, OTOH, the signal is invisible
+ * except to its handler.
+ *
+ * We don't want this difference to show. This piece of code
+ * tries to make it look like we always have restarting signals.
+ */
+ if (n <= 0 && errno == EINTR)
+ goto again;
#endif
- if ((n == -1) || (n == 0))
- {
- T(("read(%d,&ch,1)=%d, errno=%d", SP->_ifd, n, errno));
- return ERR;
- }
- T(("read %d characters", n));
-
- SP->_fifo[tail] = ch;
- SP->_fifohold = 0;
- if (head == -1)
- head = peek = tail;
- t_inc();
- T(("pushed %#x at %d", ch, tail));
+ if ((n == -1) || (n == 0)) {
+ T(("read(%d,&ch,1)=%d, errno=%d", SP->_ifd, n, errno));
+ return ERR;
+ }
+ T(("read %d characters", n));
+
+ SP->_fifo[tail] = ch;
+ SP->_fifohold = 0;
+ if (head == -1)
+ head = peek = tail;
+ t_inc();
+ T(("pushed %#x at %d", ch, tail));
#ifdef TRACE
- if (_nc_tracing & TRACE_IEVENT) _nc_fifo_dump();
+ if (_nc_tracing & TRACE_IEVENT)
+ _nc_fifo_dump();
#endif
- return ch;
+ return ch;
}
-static inline void fifo_clear(void)
+static inline void
+fifo_clear(void)
{
-int i;
- for (i = 0; i < FIFO_SIZE; i++)
- SP->_fifo[i] = 0;
- head = -1; tail = peek = 0;
+ int i;
+ for (i = 0; i < FIFO_SIZE; i++)
+ SP->_fifo[i] = 0;
+ head = -1;
+ tail = peek = 0;
}
static int kgetch(WINDOW *);
int
wgetch(WINDOW *win)
{
-int ch;
+ int ch;
- T((T_CALLED("wgetch(%p)"), win));
+ T((T_CALLED("wgetch(%p)"), win));
- if (!win)
- returnCode(ERR);
+ if (!win)
+ returnCode(ERR);
- if (cooked_key_in_fifo())
- {
- if (wgetch_should_refresh(win))
- wrefresh(win);
+ if (cooked_key_in_fifo()) {
+ if (wgetch_should_refresh(win))
+ wrefresh(win);
- ch = fifo_pull();
- T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch));)
- returnCode(ch);
- }
+ ch = fifo_pull();
+ T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch)));
+ returnCode(ch);
+ }
- /*
- * Handle cooked mode. Grab a string from the screen,
- * stuff its contents in the FIFO queue, and pop off
- * the first character to return it.
- */
- if (head == -1 && !SP->_raw && !SP->_cbreak)
- {
- char buf[MAXCOLUMNS], *sp;
+ /*
+ * Handle cooked mode. Grab a string from the screen,
+ * stuff its contents in the FIFO queue, and pop off
+ * the first character to return it.
+ */
+ if (head == -1 && !SP->_raw && !SP->_cbreak) {
+ char buf[MAXCOLUMNS], *sp;
- T(("filling queue in cooked mode"));
+ T(("filling queue in cooked mode"));
- wgetnstr(win, buf, MAXCOLUMNS);
+ wgetnstr(win, buf, MAXCOLUMNS);
- /* ungetch in reverse order */
- ungetch('\n');
- for (sp = buf+strlen(buf); sp>buf; sp--)
- ungetch(sp[-1]);
+ /* ungetch in reverse order */
+ ungetch('\n');
+ for (sp = buf + strlen(buf); sp > buf; sp--)
+ ungetch(sp[-1]);
- returnCode(fifo_pull());
- }
+ returnCode(fifo_pull());
+ }
- if (wgetch_should_refresh(win))
- wrefresh(win);
+ if (wgetch_should_refresh(win))
+ wrefresh(win);
- if (!win->_notimeout && (win->_delay >= 0 || SP->_cbreak > 1))
- {
- int delay;
+ if (!win->_notimeout && (win->_delay >= 0 || SP->_cbreak > 1)) {
+ int delay;
- T(("timed delay in wgetch()"));
- if (SP->_cbreak > 1)
- delay = (SP->_cbreak - 1) * 100;
- else
- delay = win->_delay;
+ T(("timed delay in wgetch()"));
+ if (SP->_cbreak > 1)
+ delay = (SP->_cbreak - 1) * 100;
+ else
+ delay = win->_delay;
- T(("delay is %d milliseconds", delay));
+ T(("delay is %d milliseconds", delay));
- if (head == -1) /* fifo is empty */
- if (!_nc_timed_wait(3, delay, (int *)0))
- returnCode(ERR);
- /* else go on to read data available */
- }
+ if (head == -1) /* fifo is empty */
+ if (!_nc_timed_wait(3, delay, (int *) 0))
+ returnCode(ERR);
+ /* else go on to read data available */
+ }
- if (win->_use_keypad)
- {
- /*
- * This is tricky. We only want to get special-key
- * events one at a time. But we want to accumulate
- * mouse events until either (a) the mouse logic tells
- * us it's picked up a complete gesture, or (b)
- * there's a detectable time lapse after one.
- *
- * Note: if the mouse code starts failing to compose
- * press/release events into clicks, you should probably
- * increase the wait with mouseinterval().
- */
- int runcount = 0;
-
- do {
- ch = kgetch(win);
- if (ch == KEY_MOUSE)
- {
- ++runcount;
- if (SP->_mouse_inline(SP))
- break;
- }
- } while
- (ch == KEY_MOUSE
- && (_nc_timed_wait(3, SP->_maxclick, (int *)0)
- || !SP->_mouse_parse(runcount)));
- if (runcount > 0 && ch != KEY_MOUSE)
- {
- /* mouse event sequence ended by keystroke, push it */
- ungetch(ch);
- ch = KEY_MOUSE;
- }
- } else {
- if (head == -1)
- fifo_push();
- ch = fifo_pull();
+ if (win->_use_keypad) {
+ /*
+ * This is tricky. We only want to get special-key
+ * events one at a time. But we want to accumulate
+ * mouse events until either (a) the mouse logic tells
+ * us it's picked up a complete gesture, or (b)
+ * there's a detectable time lapse after one.
+ *
+ * Note: if the mouse code starts failing to compose
+ * press/release events into clicks, you should probably
+ * increase the wait with mouseinterval().
+ */
+ int runcount = 0;
+
+ do {
+ ch = kgetch(win);
+ if (ch == KEY_MOUSE) {
+ ++runcount;
+ if (SP->_mouse_inline(SP))
+ break;
+ }
+ } while
+ (ch == KEY_MOUSE
+ && (_nc_timed_wait(3, SP->_maxclick, (int *) 0)
+ || !SP->_mouse_parse(runcount)));
+ if (runcount > 0 && ch != KEY_MOUSE) {
+ /* mouse event sequence ended by keystroke, push it */
+ ungetch(ch);
+ ch = KEY_MOUSE;
}
+ } else {
+ if (head == -1)
+ fifo_push();
+ ch = fifo_pull();
+ }
- if (ch == ERR)
- {
+ if (ch == ERR) {
#if USE_SIZECHANGE
- if(SP->_sig_winch)
- {
- _nc_update_screensize();
- /* resizeterm can push KEY_RESIZE */
- if(cooked_key_in_fifo())
- {
- ch = fifo_pull();
- T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch));)
- returnCode(ch);
- }
+ if (SP->_sig_winch) {
+ _nc_update_screensize();
+ /* resizeterm can push KEY_RESIZE */
+ if (cooked_key_in_fifo()) {
+ ch = fifo_pull();
+ T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch)));
+ returnCode(ch);
}
-#endif
- T(("wgetch returning ERR"));
- returnCode(ERR);
}
-
- /*
- * Simulate ICRNL mode
- */
- if ((ch == '\r') && SP->_nl)
- ch = '\n';
-
- /* Strip 8th-bit if so desired. We do this only for characters that
- * are in the range 128-255, to provide compatibility with terminals
- * that display only 7-bit characters. Note that 'ch' may be a
- * function key at this point, so we mustn't strip _those_.
- */
- if ((ch < KEY_MIN) && (ch & 0x80))
- if (!SP->_use_meta)
- ch &= 0x7f;
-
- if (SP->_echo && ch < KEY_MIN && !(win->_flags & _ISPAD))
- wechochar(win, (chtype)ch);
-
- T(("wgetch returning : %#x = %s", ch, _trace_key(ch)));
-
- returnCode(ch);
+#endif
+ T(("wgetch returning ERR"));
+ returnCode(ERR);
+ }
+
+ /*
+ * Simulate ICRNL mode
+ */
+ if ((ch == '\r') && SP->_nl)
+ ch = '\n';
+
+ /* Strip 8th-bit if so desired. We do this only for characters that
+ * are in the range 128-255, to provide compatibility with terminals
+ * that display only 7-bit characters. Note that 'ch' may be a
+ * function key at this point, so we mustn't strip _those_.
+ */
+ if ((ch < KEY_MIN) && (ch & 0x80))
+ if (!SP->_use_meta)
+ ch &= 0x7f;
+
+ if (SP->_echo && ch < KEY_MIN && !(win->_flags & _ISPAD))
+ wechochar(win, (chtype) ch);
+
+ T(("wgetch returning : %#x = %s", ch, _trace_key(ch)));
+
+ returnCode(ch);
}
-
/*
** int
** kgetch()
static int
kgetch(WINDOW *win GCC_UNUSED)
{
-struct tries *ptr;
-int ch = 0;
-int timeleft = ESCDELAY;
-
- TR(TRACE_IEVENT, ("kgetch(%p) called", win));
-
- ptr = SP->_keytry;
-
- for(;;)
- {
- if (!raw_key_in_fifo())
- {
- if(fifo_push() == ERR)
- {
- peek = head; /* the keys stay uninterpreted */
- return ERR;
- }
- }
- ch = fifo_peek();
- if (ch >= KEY_MIN)
- {
- peek = head;
- /* assume the key is the last in fifo */
- t_dec(); /* remove the key */
- return ch;
- }
-
- TR(TRACE_IEVENT, ("ch: %s", _trace_key((unsigned char)ch)));
- while ((ptr != NULL) && (ptr->ch != (unsigned char)ch))
- ptr = ptr->sibling;
+ struct tries *ptr;
+ int ch = 0;
+ int timeleft = ESCDELAY;
+
+ TR(TRACE_IEVENT, ("kgetch(%p) called", win));
+
+ ptr = SP->_keytry;
+
+ for (;;) {
+ if (!raw_key_in_fifo()) {
+ if (fifo_push() == ERR) {
+ peek = head; /* the keys stay uninterpreted */
+ return ERR;
+ }
+ }
+ ch = fifo_peek();
+ if (ch >= KEY_MIN) {
+ peek = head;
+ /* assume the key is the last in fifo */
+ t_dec(); /* remove the key */
+ return ch;
+ }
+
+ TR(TRACE_IEVENT, ("ch: %s", _trace_key((unsigned char) ch)));
+ while ((ptr != NULL) && (ptr->ch != (unsigned char) ch))
+ ptr = ptr->sibling;
#ifdef TRACE
- if (ptr == NULL)
- {TR(TRACE_IEVENT, ("ptr is null"));}
- else
- TR(TRACE_IEVENT, ("ptr=%p, ch=%d, value=%d",
- ptr, ptr->ch, ptr->value));
+ if (ptr == NULL) {
+ TR(TRACE_IEVENT, ("ptr is null"));
+ } else
+ TR(TRACE_IEVENT, ("ptr=%p, ch=%d, value=%d",
+ ptr, ptr->ch, ptr->value));
#endif /* TRACE */
- if (ptr == NULL)
- break;
-
- if (ptr->value != 0) { /* sequence terminated */
- TR(TRACE_IEVENT, ("end of sequence"));
- if (peek == tail)
- fifo_clear();
- else
- head = peek;
- return(ptr->value);
- }
-
- ptr = ptr->child;
-
- if (!raw_key_in_fifo())
- {
- TR(TRACE_IEVENT, ("waiting for rest of sequence"));
- if (!_nc_timed_wait(3, timeleft, &timeleft)) {
- TR(TRACE_IEVENT, ("ran out of time"));
- break;
- }
- }
+ if (ptr == NULL)
+ break;
+
+ if (ptr->value != 0) { /* sequence terminated */
+ TR(TRACE_IEVENT, ("end of sequence"));
+ if (peek == tail)
+ fifo_clear();
+ else
+ head = peek;
+ return (ptr->value);
}
- ch = fifo_pull();
- peek = head;
- return ch;
+
+ ptr = ptr->child;
+
+ if (!raw_key_in_fifo()) {
+ TR(TRACE_IEVENT, ("waiting for rest of sequence"));
+ if (!_nc_timed_wait(3, timeleft, &timeleft)) {
+ TR(TRACE_IEVENT, ("ran out of time"));
+ break;
+ }
+ }
+ }
+ ch = fifo_pull();
+ peek = head;
+ return ch;
}
-/* $OpenBSD: lib_mouse.c,v 1.7 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: lib_mouse.c,v 1.8 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#endif
#endif
-MODULE_ID("$From: lib_mouse.c,v 1.48 2000/01/08 17:34:43 tom Exp $");
+MODULE_ID("$From: lib_mouse.c,v 1.50 2000/02/13 00:59:39 tom Exp $")
#define MY_TRACE TRACE_ICALLS|TRACE_IEVENT
-/* $OpenBSD: lib_newterm.c,v 1.6 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_newterm.c,v 1.7 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h> /* clear_screen, cup & friends, cur_term */
#include <tic.h>
-MODULE_ID("$From: lib_newterm.c,v 1.43 2000/01/01 16:56:20 tom Exp $")
+MODULE_ID("$From: lib_newterm.c,v 1.44 2000/02/13 00:59:39 tom Exp $")
#ifndef ONLCR /* Allows compilation under the QNX 4.2 OS */
#define ONLCR 0
-/* $OpenBSD: lib_nl.c,v 1.3 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: lib_nl.c,v 1.4 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <curses.priv.h>
-MODULE_ID("$From: lib_nl.c,v 1.5 2000/01/08 17:33:30 tom Exp $")
+MODULE_ID("$From: lib_nl.c,v 1.6 2000/02/13 00:59:39 tom Exp $")
#ifdef __EMX__
#include <io.h>
-/* $OpenBSD: lib_pad.c,v 1.1 1999/01/18 19:09:55 millert Exp $ */
+/* $OpenBSD: lib_pad.c,v 1.2 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
* Copyright (c) 1998 Free Software Foundation, Inc. *
#include <curses.priv.h>
-MODULE_ID("$From: lib_pad.c,v 1.27 1998/06/28 00:10:16 tom Exp $")
+MODULE_ID("$From: lib_pad.c,v 1.28 2000/03/05 00:21:55 David.Mosberger Exp $")
WINDOW *newpad(int l, int c)
{
newscr->_cury = win->_cury - pminrow + win->_begy + win->_yoffset;
newscr->_curx = win->_curx - pmincol + win->_begx;
}
+ newscr->_leaveok = win->_leaveok;
win->_flags &= ~_HASMOVED;
/*
-/* $OpenBSD: lib_set_term.c,v 1.6 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_set_term.c,v 1.7 2000/03/10 01:35:02 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h> /* cur_term */
#include <tic.h>
-MODULE_ID("$From: lib_set_term.c,v 1.49 2000/01/01 16:44:29 tom Exp $")
+MODULE_ID("$From: lib_set_term.c,v 1.50 2000/02/13 00:59:39 tom Exp $")
SCREEN *
set_term(SCREEN * screenp)
-/* $OpenBSD: wresize.c,v 1.2 1999/03/02 06:23:28 millert Exp $ */
+/* $OpenBSD: wresize.c,v 1.3 2000/03/10 01:35:03 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <curses.priv.h>
-MODULE_ID("$From: wresize.c,v 1.12 1999/02/27 18:57:31 tom Exp $")
+MODULE_ID("$From: wresize.c,v 1.16 2000/03/05 00:14:35 tom Exp $")
/*
* Reallocate a curses WINDOW struct to either shrink or grow to the specified
int
wresize(WINDOW *win, int ToLines, int ToCols)
{
- register int row;
- int size_x, size_y;
- struct ldat *pline;
- chtype blank;
+ register int row;
+ int size_x, size_y;
+ struct ldat *pline;
+ chtype blank;
#ifdef TRACE
- T((T_CALLED("wresize(%p,%d,%d)"), win, ToLines, ToCols));
- if (win) {
- TR(TRACE_UPDATE, ("...beg (%d, %d), max(%d,%d), reg(%d,%d)",
- win->_begy, win->_begx,
- win->_maxy, win->_maxx,
- win->_regtop, win->_regbottom));
- if (_nc_tracing & TRACE_UPDATE)
+ T((T_CALLED("wresize(%p,%d,%d)"), win, ToLines, ToCols));
+ if (win) {
+ TR(TRACE_UPDATE, ("...beg (%d, %d), max(%d,%d), reg(%d,%d)",
+ win->_begy, win->_begx,
+ win->_maxy, win->_maxx,
+ win->_regtop, win->_regbottom));
+ if (_nc_tracing & TRACE_UPDATE)
_tracedump("...before", win);
- }
+ }
#endif
- if (!win || --ToLines < 0 || --ToCols < 0)
- returnCode(ERR);
+ if (!win || --ToLines < 0 || --ToCols < 0)
+ returnCode(ERR);
- size_x = win->_maxx;
- size_y = win->_maxy;
+ size_x = win->_maxx;
+ size_y = win->_maxy;
- if (ToLines == size_y
- && ToCols == size_x)
- returnCode(OK);
-
- pline = (win->_flags & _SUBWIN) ? win->_parent->_line : 0;
+ if (ToLines == size_y
+ && ToCols == size_x)
+ returnCode(OK);
+ if ((win->_flags & _SUBWIN)) {
/*
- * If the number of lines has changed, adjust the size of the overall
- * vector:
+ * Check if the new limits will fit into the parent window's size. If
+ * not, do not resize. We could adjust the location of the subwindow,
+ * but the application may not like that.
*/
- if (ToLines != size_y) {
- if (! (win->_flags & _SUBWIN)) {
- for (row = ToLines+1; row <= size_y; row++)
- free((char *)(win->_line[row].text));
- }
-
- win->_line = ld_ALLOC(win->_line, ToLines+1);
- if (win->_line == 0)
- returnCode(ERR);
-
- for (row = size_y+1; row <= ToLines; row++) {
- win->_line[row].text = 0;
- win->_line[row].firstchar = 0;
- win->_line[row].lastchar = ToCols;
- if ((win->_flags & _SUBWIN)) {
- win->_line[row].text =
- &pline[win->_begy + row].text[win->_begx];
- }
- }
+ if (win->_pary + ToLines > win->_parent->_maxy
+ || win->_parx + ToCols > win->_parent->_maxx) {
+ returnCode(ERR);
}
-
- /*
- * Adjust the width of the columns:
- */
- blank = _nc_background(win);
- for (row = 0; row <= ToLines; row++) {
- chtype *s = win->_line[row].text;
- int begin = (s == 0) ? 0 : size_x + 1;
- int end = ToCols;
-
- if_USE_SCROLL_HINTS(win->_line[row].oldindex = row);
-
- if (ToCols != size_x || s == 0) {
- if (! (win->_flags & _SUBWIN)) {
- win->_line[row].text = s = c_ALLOC(s, ToCols+1);
- if (win->_line[row].text == 0)
- returnCode(ERR);
- } else if (s == 0) {
- win->_line[row].text = s =
- &pline[win->_begy + row].text[win->_begx];
- }
-
- if (end >= begin) { /* growing */
- if (win->_line[row].firstchar < begin)
- win->_line[row].firstchar = begin;
- win->_line[row].lastchar = ToCols;
- do {
- s[end] = blank;
- } while (--end >= begin);
- } else { /* shrinking */
- win->_line[row].firstchar = 0;
- win->_line[row].lastchar = ToCols;
- }
- }
+ pline = win->_parent->_line;
+ } else {
+ pline = 0;
+ }
+
+ /*
+ * If the number of lines has changed, adjust the size of the overall
+ * vector:
+ */
+ if (ToLines != size_y) {
+ if (!(win->_flags & _SUBWIN)) {
+ for (row = ToLines + 1; row <= size_y; row++)
+ free((char *) (win->_line[row].text));
}
- /*
- * Finally, adjust the parameters showing screen size and cursor
- * position:
- */
- win->_maxx = ToCols;
- win->_maxy = ToLines;
-
- if (win->_regtop > win->_maxy)
- win->_regtop = win->_maxy;
- if (win->_regbottom > win->_maxy
- || win->_regbottom == size_y)
- win->_regbottom = win->_maxy;
-
- if (win->_curx > win->_maxx)
- win->_curx = win->_maxx;
- if (win->_cury > win->_maxy)
- win->_cury = win->_maxy;
+ win->_line = ld_ALLOC(win->_line, ToLines + 1);
+ if (win->_line == 0)
+ returnCode(ERR);
+
+ for (row = size_y + 1; row <= ToLines; row++) {
+ win->_line[row].text = 0;
+ win->_line[row].firstchar = 0;
+ win->_line[row].lastchar = ToCols;
+ if ((win->_flags & _SUBWIN)) {
+ win->_line[row].text =
+ &pline[win->_pary + row].text[win->_parx];
+ }
+ }
+ }
+
+ /*
+ * Adjust the width of the columns:
+ */
+ blank = _nc_background(win);
+ for (row = 0; row <= ToLines; row++) {
+ chtype *s = win->_line[row].text;
+ int begin = (s == 0) ? 0 : size_x + 1;
+ int end = ToCols;
+
+ if_USE_SCROLL_HINTS(win->_line[row].oldindex = row);
+
+ if (ToCols != size_x || s == 0) {
+ if (!(win->_flags & _SUBWIN)) {
+ win->_line[row].text = s = c_ALLOC(s, ToCols + 1);
+ if (win->_line[row].text == 0)
+ returnCode(ERR);
+ } else if (s == 0) {
+ win->_line[row].text = s =
+ &pline[win->_pary + row].text[win->_parx];
+ }
+
+ if (end >= begin) { /* growing */
+ if (win->_line[row].firstchar < begin)
+ win->_line[row].firstchar = begin;
+ win->_line[row].lastchar = ToCols;
+ do {
+ s[end] = blank;
+ } while (--end >= begin);
+ } else { /* shrinking */
+ win->_line[row].firstchar = 0;
+ win->_line[row].lastchar = ToCols;
+ }
+ }
+ }
+
+ /*
+ * Finally, adjust the parameters showing screen size and cursor
+ * position:
+ */
+ win->_maxx = ToCols;
+ win->_maxy = ToLines;
+
+ if (win->_regtop > win->_maxy)
+ win->_regtop = win->_maxy;
+ if (win->_regbottom > win->_maxy
+ || win->_regbottom == size_y)
+ win->_regbottom = win->_maxy;
+
+ if (win->_curx > win->_maxx)
+ win->_curx = win->_maxx;
+ if (win->_cury > win->_maxy)
+ win->_cury = win->_maxy;
#ifdef TRACE
- TR(TRACE_UPDATE, ("...beg (%d, %d), max(%d,%d), reg(%d,%d)",
- win->_begy, win->_begx,
- win->_maxy, win->_maxx,
- win->_regtop, win->_regbottom));
- if (_nc_tracing & TRACE_UPDATE)
- _tracedump("...after:", win);
+ TR(TRACE_UPDATE, ("...beg (%d, %d), max(%d,%d), reg(%d,%d)",
+ win->_begy, win->_begx,
+ win->_maxy, win->_maxx,
+ win->_regtop, win->_regbottom));
+ if (_nc_tracing & TRACE_UPDATE)
+ _tracedump("...after:", win);
#endif
- returnCode(OK);
+ returnCode(OK);
}
'\" t
-.\" $OpenBSD: curs_attr.3tbl,v 1.7 1999/01/18 19:07:11 millert Exp $
+.\" $OpenBSD: curs_attr.3tbl,v 1.8 2000/03/10 01:35:01 millert Exp $
.\"
.\"***************************************************************************
-.\" Copyright (c) 1998 Free Software Foundation, Inc. *
+.\" Copyright (c) 1998,2000 Free Software Foundation, Inc. *
.\" *
.\" Permission is hereby granted, free of charge, to any person obtaining a *
.\" copy of this software and associated documentation files (the *
.\" authorization. *
.\"***************************************************************************
.\"
-.\" $From: curs_attr.3x,v 1.19 1998/12/26 19:25:35 tom Exp $
+.\" $From: curs_attr.3x,v 1.20 2000/02/27 01:46:31 tom Exp $
.TH curs_attr 3 ""
.SH NAME
\fBattroff\fR, \fBwattroff\fR, \fBattron\fR, \fBwattron\fR,
.br
\fBint wattr_on(WINDOW *win, attr_t attrs, void *opts);\fR
.br
-\fBint attr_set(attr_t attrs, void *opts);\fR
+\fBint attr_set(attr_t attrs, short pair, void *opts);\fR
.br
-\fBint wattr_set(WINDOW *win, attr_t attrs, void *opts);\fR
+\fBint wattr_set(WINDOW *win, attr_t attrs, short pair, void *opts);\fR
.br
\fBint chgat(int n, attr_t attr, short color,\fR
\fBconst void *opts)\fR
-.\" $OpenBSD: curs_kernel.3,v 1.7 1998/09/13 19:16:20 millert Exp $
+.\" $OpenBSD: curs_kernel.3,v 1.8 2000/03/10 01:35:01 millert Exp $
.\"
.\"***************************************************************************
.\" Copyright (c) 1998 Free Software Foundation, Inc. *
.\" authorization. *
.\"***************************************************************************
.\"
-.\" $From: curs_kernel.3x,v 1.11 1998/06/27 21:56:38 tom Exp $
+.\" $From: curs_kernel.3x,v 1.12 2000/02/27 01:37:46 tom Exp $
.TH curs_kernel 3 ""
.SH NAME
\fBdef_prog_mode\fR, \fBdef_shell_mode\fR,
Older SVr4 man pages warn that the return value of \fBcurs_set\fR "is currently
incorrect". This implementation gets it right, but it may be unwise to count
on the correctness of the return value anywhere else.
+
+Both ncurses and SVr4 will call \fBcurs_set\fR in \fBendwin\fR
+if \fBcurs_set\fR
+has been called to make the cursor other than normal, i.e., either
+visible or very visible.
+There is no way for ncurses to determine the initial cursor state to
+restore that.
.SH PORTABILITY
The functions \fBsetsyx\fR and \fBgetsyx\fR are not described in the XSI
Curses standard, Issue 4. All other functions are as described in XSI Curses.
-.\" $OpenBSD: curs_outopts.3,v 1.7 1999/01/18 19:07:14 millert Exp $
+.\" $OpenBSD: curs_outopts.3,v 1.8 2000/03/10 01:35:01 millert Exp $
.\"
.\"***************************************************************************
.\" Copyright (c) 1998 Free Software Foundation, Inc. *
.\" authorization. *
.\"***************************************************************************
.\"
-.\" $From: curs_outopts.3x,v 1.13 1998/12/26 20:02:04 tom Exp $
+.\" $From: curs_outopts.3x,v 1.14 2000/02/27 01:41:58 tom Exp $
.TH curs_outopts 3 ""
.SH NAME
\fBclearok\fR, \fBidlok\fR, \fBidcok immedok\fR,
The XSI Curses standard does not mention that the cursor should be
made invisible as a side-effect of \fBleaveok\fR.
SVr4 curses documentation does this, but the code does not.
+Use \fBcurs_set\fR to make the cursor invisible.
.SH NOTES
Note that \fBclearok\fR, \fBleaveok\fR, \fBscrollok\fR, \fBidcok\fR, \fBnl\fR,
\fBnonl\fR and \fBsetscrreg\fR may be macros.
-/* $OpenBSD: curses.h,v 1.46 2000/02/06 07:10:50 millert Exp $ */
+/* $OpenBSD: curses.h,v 1.47 2000/03/10 01:35:01 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
****************************************************************************/
-/* $From: curses.h.in,v 1.89 2000/01/09 01:10:20 tom Exp $ */
+/* $From: curses.h.in,v 1.90 2000/02/19 22:15:43 tom Exp $ */
#ifndef __NCURSES_H
#define __NCURSES_H
/* These are defined only in curses.h, and are used for conditional compiles */
#define NCURSES_VERSION_MAJOR 5
#define NCURSES_VERSION_MINOR 0
-#define NCURSES_VERSION_PATCH 20000129
+#define NCURSES_VERSION_PATCH 20000304
/* This is defined in more than one ncurses header, for identification */
#undef NCURSES_VERSION
-/* $OpenBSD: curses.priv.h,v 1.24 2000/02/06 07:10:50 millert Exp $ */
+/* $OpenBSD: curses.priv.h,v 1.25 2000/03/10 01:35:01 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
/*
- * $From: curses.priv.h,v 1.151 2000/02/06 01:57:01 tom Exp $
+ * $From: curses.priv.h,v 1.153 2000/02/19 23:31:39 tom Exp $
*
* curses.priv.h
*
vidattr(AttrOf(c))
#endif
-/*
- * Check whether the given character can be output by clearing commands. This
- * includes test for being a space and not including any 'bad' attributes, such
- * as A_REVERSE. All attribute flags which don't affect appearance of a space
- * or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.
- */
-#define can_clear_with(ch) \
- ((ch & ~(NONBLANK_ATTR|(back_color_erase ? A_COLOR:0))) == BLANK)
-
#ifdef NCURSES_EXPANDED
#undef toggle_attr_on
#define toggle_attr_off(S,at) _nc_toggle_attr_off(&(S), at)
extern void _nc_toggle_attr_off(attr_t *, attr_t);
-#undef can_clear_with
-#define can_clear_with(ch) _nc_can_clear_with(ch)
-extern int _nc_can_clear_with(chtype);
-
#undef DelCharCost
#define DelCharCost(count) _nc_DelCharCost(count)
extern int _nc_DelCharCost(int);
-.\" $OpenBSD: dft_fgbg.3,v 1.4 1999/11/28 17:53:40 millert Exp $
+.\" $OpenBSD: dft_fgbg.3,v 1.5 2000/03/10 01:35:01 millert Exp $
.\"
.\"***************************************************************************
-.\" Copyright (c) 1998,1999 Free Software Foundation, Inc. *
+.\" Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
.\" *
.\" Permission is hereby granted, free of charge, to any person obtaining a *
.\" copy of this software and associated documentation files (the *
.\"
.\" Author: Thomas E. Dickey <dickey@clark.net> 1997,1999
.\"
-.\" $From: dft_fgbg.3x,v 1.7 1999/11/14 00:51:50 tom Exp $
+.\" $From: dft_fgbg.3x,v 1.9 2000/02/13 02:28:39 tom Exp $
.TH use_default_colors 3 ""
.SH NAME
\fBdft_fgbg\fR \- use terminal's default colors
They are used with terminals that support ISO 6429 color, or equivalent.
These terminals allow the application to reset color to an unspecified
default value (e.g., with SGR 39 or SGR 49).
-XSI Curses assumes the default colors are white on black.
.PP
Applications that paint a colored background over the whole screen
do not take advantage of SGR 39 and SGR 49.
.PP
The first function,
.I use_default_colors()
-tells the curses library to use the terminal's
-\fIorig_pair\fP or \fIorig_colors\fP capability when setting color pair 0.
+tells the curses library to assign terminal default
+foreground/background colors to color number -1. So init_pair(x,COLOR_RED,-1)
+will initialize pair x as red on default background and init_pair(x,-1,COLOR_BLUE) will
+initialize pair x as default foreground on blue.
.PP
The other,
.I assume_default_colors()
-is a refinement which tells which colors to assume are set for color pair 0.
+is a refinement which tells which colors to paint for color pair 0, and -1 means default terminal color.
The following are equivalent:
.RS
.br
.I assume_default_colors(-1,-1);
.RE
.PP
-Do this:
-.RS
-.I assume_default_colors(COLOR_WHITE,COLOR_BLACK);
-.RE
-to disable default colors.
+This is a ncurses extension and for other curses implementations color
+number -1 does not mean anything, just as for ncurses before a
+successful call of use_default_colors or assume_default_colors.
..
.SH RETURN VALUE
These functions return the integer \fBERR\fP upon failure and \fBOK\fP on success.
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 3.0//EN">
<!--
- $From: hackguide.html,v 1.23 1999/01/17 00:15:48 tom Exp $
+ $From: hackguide.html,v 1.24 2000/03/05 01:19:41 tom Exp $
-->
<HTML>
<HEAD>
<H1>Contents</H1>
<UL>
<LI><A HREF="#abstract">Abstract</A>
-<P>
<LI><A HREF="#objective">Objective of the Package</A>
<UL>
<LI><A HREF="#whysvr4">Why System V Curses?</A>
<LI><A HREF="#extensions">How to Design Extensions</A>
</UL>
-<LI><A HREF="#portability">Portability and Configuration</A><UL>
-</UL>
+<LI><A HREF="#portability">Portability and Configuration</A>
<LI><A HREF="#documentation">Documentation Conventions</A>
-<P>
<LI><A HREF="#bugtrack">How to Report Bugs</A>
-<P>
<LI><A HREF="#ncurslib">A Tour of the Ncurses Library</A>
<UL>
<LI><A HREF="#loverview">Library Overview</A>
<LI><A HREF="#output">Output and Screen Updating</A>
</UL>
<LI><A HREF="#fmnote">The Forms and Menu Libraries</A>
-<P>
<LI><A HREF="#tic">A Tour of the Terminfo Compiler</A>
<UL>
<LI><A HREF="#nonuse">Translation of Non-<STRONG>use</STRONG> Capabilities</A>
<LI><A HREF="#translation">Source-Form Translation</A>
</UL>
<LI><A HREF="#utils">Other Utilities</A>
-<P>
<LI><A HREF="#style">Style Tips for Developers</A>
-<P>
<LI><A HREF="#port">Porting Hints</A>
</UL>
It discusses design philosophy, implementation methods, and the
conventions used for coding and documentation. It is recommended
reading for anyone who is interested in porting, extending or improving the
-package. <P>
+package.
<H1><A NAME="objective">Objective of the Package</A></H1>
The objective of the <STRONG>ncurses</STRONG> package is to provide a free software API for
character-cell terminals and terminal emulators with the following
-characteristics: <P>
+characteristics:
<UL>
<LI>Source-compatible with historical curses implementations (including
the original BSD curses and System V curses.
-<P>
<LI>Conformant with the XSI Curses standard issued as part of XPG4 by
X/Open.
-<P>
<LI>High-quality -- stable and reliable code, wide portability, good
packaging, superior documentation.
-<P>
<LI>Featureful -- should eliminate as much of the drudgery of C interface
programming as possible, freeing programmers to think at a higher
level of design.
These objectives are in priority order. So, for example, source
compatibility with older version must trump featurefulness -- we cannot
add features if it means breaking the portion of the API corresponding
-to historical curses versions. <P>
+to historical curses versions.
<H2><A NAME="whysvr4">Why System V Curses?</A></H2>
More importantly for the future, the XSI Curses standard issued by X/Open
is explicitly and closely modeled on System V. So conformance with
-System V took us most of the way to base-level XSI conformance. <P>
+System V took us most of the way to base-level XSI conformance.
<H2><A NAME="extensions">How to Design Extensions</A></H2>
For example, there is a macro <CODE>NCURSES_MOUSE_VERSION</CODE> which XSI Curses
does not define, but which is defined in the <STRONG>ncurses</STRONG> library header.
-You can use this to condition the calls to the mouse API calls. <P>
+You can use this to condition the calls to the mouse API calls.
<H1><A NAME="portability">Portability and Configuration</A></H1>
to less-capable UNIX environments wherever possible. <P>
We encourage developers to support OS-specific optimizations and methods
-not available under POSIX/ANSI, provided only that: <P>
+not available under POSIX/ANSI, provided only that:
<UL>
<LI>All such code is properly conditioned so the build process does not
attempt to compile it under a plain ANSI/POSIX environment.
-<P>
<LI>Adding such implementation methods does not introduce incompatibilities
in the <STRONG>ncurses</STRONG> API between platforms.
</UL>
We use GNU <CODE>autoconf(1)</CODE> as a tool to deal with portability issues.
The right way to leverage an OS-specific feature is to modify the autoconf
specification files (configure.in and aclocal.m4) to set up a new feature
-macro, which you then use to condition your code. <P>
+macro, which you then use to condition your code.
<H1><A NAME="documentation">Documentation Conventions</A></H1>
There are three kinds of documentation associated with this package. Each
-has a different preferred format: <P>
+has a different preferred format:
<UL>
<LI>Package-internal files (README, INSTALL, TO-DO etc.)
<LI>Everything else (i.e., narrative documentation).
</UL>
-Our conventions are simple: <P>
+Our conventions are simple:
<OL>
<LI><STRONG>Maintain package-internal files in plain text.</STRONG>
The expected viewer for them <EM>more(1)</EM> or an editor window; there's
- no point in elaborate mark-up. <P>
+ no point in elaborate mark-up.
<LI><STRONG>Mark up manual pages in the man macros.</STRONG> These have to be viewable
- through traditional <EM>man(1)</EM> programs. <P>
+ through traditional <EM>man(1)</EM> programs.
<LI><STRONG>Write everything else in HTML.</STRONG>
</OL>
as plain text than most other mark-ups, if you don't have a viewer; and (c)
carries enough information that you can generate a nice-looking printed
version from it. Also, of course, it make exporting things like the
-announcement document to WWW pretty trivial.<P>
+announcement document to WWW pretty trivial.
<H1><A NAME="bugtrack">How to Report Bugs</A></H1>
In order to use our bug-fixing time efficiently, we put people who
show us they've taken these steps at the head of our queue. This
means that if you don't, you'll probably end up at the tail end and
-have to wait a while. <P>
+have to wait a while.
<OL>
-<LI>Develop a recipe to reproduce the bug. <P>
+<LI>Develop a recipe to reproduce the bug.
Bugs we can reproduce are likely to be fixed very quickly, often
within days. The most effective single thing you can do to get a
quick fix is develop a way we can duplicate the bad behavior --
ideally, by giving us source for a small, portable test program that
breaks the library. (Even better is a keystroke recipe using one of
-the test programs provided with the distribution.) <P>
+the test programs provided with the distribution.)
<LI>Try to reproduce the bug on a different terminal type. <P>
If you have xterm available, it is also good to collect xterm reports for
different window sizes. This is especially true if you normally use an
unusual xterm window size -- a surprising number of the bugs we've seen
-are either triggered or masked by these. <P>
+are either triggered or masked by these.
<LI>Generate and examine a trace file for the broken behavior. <P>
Often you'll find terminfo problems at this stage by noticing that the
escape sequences put out for various capabilities are wrong. If not,
you're likely to learn enough to be able to characterize any bug in
-the screen-update logic quite exactly. <P>
+the screen-update logic quite exactly.
<LI>Report details and symptoms, not just interpretations. <P>
There's one other interactive tester, <CODE>tctest</CODE>, that exercises
translation between termcap and terminfo formats. If you have a serious
-need to run this, you probably belong on our development team! <P>
+need to run this, you probably belong on our development team!
<H1><A NAME="ncurslib">A Tour of the Ncurses Library</A></H1>
reorganization in the underlying data structures. <P>
These files are used only for debugging support:
-<blockquote><code>
+<blockquote>
+<code>
lib_trace.c
lib_traceatr.c
lib_tracebits.c
lib_tracedmp.c
lib_tracemse.c
trace_buf.c
-</blockquote></code>
+</code>
+</blockquote>
It is rather unlikely you will ever need to change these, unless
you want to introduce a new debug trace level for some reasoon.<P>
computations on the terminal capabilities, or queries to the OS
environment, but nevertheless have only fairly low complexity. These
include:
-<blockquote><code>
+<blockquote>
+<code>
lib_acs.c
lib_beep.c
lib_color.c
lib_tputs.c
lib_vidattr.c
read_entry.c.
-</blockquote></code>
+</code>
+</blockquote>
They are likely to need revision only if
ncurses is being ported to an environment without an underlying
terminfo capability representation. <P>
These files
have serious hooks into
the tty driver and signal facilities:
-<blockquote><code>
+<blockquote>
+<code>
lib_kernel.c
lib_baudrate.c
lib_raw.c
lib_tstp.c
lib_twait.c
-</blockquote></code>
+</code>
+</blockquote>
If you run into porting snafus
moving the package to another UNIX, the problem is likely to be in one
of these files.
falls in this category.<P>
Almost all of the real work is done in the files
-<blockquote><code>
+<blockquote>
+<code>
hardscroll.c
hashmap.c
lib_addch.c
lib_refresh.c
lib_setup.c
lib_vidattr.c
-</blockquote></code>
+</code>
+</blockquote>
Most of the algorithmic complexity in the
library lives in these files.
If there is a real bug in <STRONG>ncurses</STRONG> itself, it's probably here.
Finally, there is a group of files that is actually most of the
terminfo compiler. The reason this code lives in the <STRONG>ncurses</STRONG>
library is to support fallback to /etc/termcap. These files include
-<blockquote><code>
+<blockquote>
+<code>
alloc_entry.c
captoinfo.c
comp_captab.c
parse_entry.c
read_termcap.c
write_entry.c
-</blockquote></code>
-We'll discuss these in the compiler tour. <P>
+</code>
+</blockquote>
+We'll discuss these in the compiler tour.
<H2><A NAME="engine">The Engine Room</A></H2>
calls may find the code in <CODE>lib_twait.c</CODE> interesting. It deals
with the problem that some BSD selects don't return a reliable
time-left value. The function <CODE>timed_wait()</CODE> effectively
-simulates a System V select. <P>
+simulates a System V select.
<H3><A NAME="mouse">Mouse Events</A></H3>
In either case, <CODE>_nc_mouse_parse()</CODE> should be called after the
series is accepted to parse the digested mouse reports (low-level
-events) into a gesture (a high-level or composite event). <P>
+events) into a gesture (a high-level or composite event).
<H3><A NAME="output">Output and Screen Updating</A></H3>
In the trace-enabled version of the library, it is also possible to disable
and re-enable various optimizations at runtime by tweaking the variable
<CODE>_nc_optimize_enable</CODE>. See the file <CODE>include/curses.h.in</CODE>
-for mask values, near the end. <P>
+for mask values, near the end.
<H1><A NAME="fmnote">The Forms and Menu Libraries</A></H1>
Historical note: the panels code was written primarily to assist in
porting u386mon 2.0 (comp.sources.misc v14i001-4) to systems lacking
panels support; u386mon 2.10 and beyond use it. This version has been
-slightly cleaned up for <CODE>ncurses</CODE>. <P>
+slightly cleaned up for <CODE>ncurses</CODE>.
<H1><A NAME="tic">A Tour of the Terminfo Compiler</A></H1>
mode (termcap or terminfo) based on the first `,' or `:' it finds in
each entry. The lexer does all the work of recognizing capability
names and values; the grammar above it is trivial, just "parse entries
-till you run out of file". <P>
+till you run out of file".
<H2><A NAME="nonuse">Translation of Non-<STRONG>use</STRONG> Capabilities</A></H2>
Thus, adding a new capability is usually pretty trivial, just a matter
of adding one line to the <CODE>include/Caps</CODE> file. We'll have more
to say about this in the section on <A HREF="#translation">Source-Form
-Translation</A>. <P>
+Translation</A>.
<H2><A NAME="uses">Use Capability Resolution</A></H2>
postdates the time of <STRONG>tic</STRONG>'s first call to
<CODE>write_entry()</CODE>, Thus it will complain about overwriting
entries newly made during the <STRONG>tic</STRONG> run, but not about
-overwriting ones that predate it. <P>
+overwriting ones that predate it.
<H2><A NAME="translation">Source-Form Translation</A></H2>
are functions in <CODE>parse_entry.c</CODE> called after the parse of each
entry that are specifically intended to encapsulate such
translations. This, for example, is where the AIX <STRONG>box1</STRONG> capability
-get translated to an <STRONG>acsc</STRONG> string.<P>
+get translated to an <STRONG>acsc</STRONG> string.
<H1><A NAME="utils">Other Utilities</A></H1>
the ordinary De-compilation case and entry difference reporting. <P>
The <STRONG>tput</STRONG> and <STRONG>clear</STRONG> utilities just do an entry load
-followed by a <CODE>tputs()</CODE> of a selected capability. <P>
+followed by a <CODE>tputs()</CODE> of a selected capability.
<H1><A NAME="style">Style Tips for Developers</A></H1>
preferable to ad-hoc code -- that's why the fifth field (flags) is
there. <P>
-Have fun! <P>
+Have fun!
<H1><A NAME="port">Porting Hints</A></H1>
calls (not including <CODE>tputs()</CODE> and <CODE>putp()</CODE>) and do not
call any other UNIX routines such as signal(2) or the stdio library.
Thus, they should not need to be modified for single-terminal
-ports. <P>
+ports.
-<blockquote><code>
+<blockquote>
+<code>
lib_addch.c
lib_addstr.c
lib_bkgd.c
lib_unctrl.c
lib_window.c
panel.c
-</blockquote></code>
+</code>
+</blockquote>
<P>
-This module is pure curses, but calls outstr(): <P>
+This module is pure curses, but calls outstr():
-<blockquote><code>
+<blockquote>
+<code>
lib_getstr.c
-</blockquote></code>
+</code>
+</blockquote>
<P>
These modules are pure curses, except that they use <CODE>tputs()</CODE>
-and <CODE>putp()</CODE>: <P>
+and <CODE>putp()</CODE>:
-<blockquote><code>
+<blockquote>
+<code>
lib_beep.c
lib_color.c
lib_endwin.c
lib_options.c
lib_slk.c
lib_vidattr.c
-</blockquote></code>
+</code>
+</blockquote>
<P>
-This modules assist in POSIX emulation on non-POSIX systems: <P>
+This modules assist in POSIX emulation on non-POSIX systems:
<DL>
<DT> sigaction.c
<DD> signal calls
</DL>
The following source files will not be needed for a
-single-terminal-type port. <P>
+single-terminal-type port.
-<blockquote><code>
+<blockquote>
+<code>
alloc_entry.c
captoinfo.c
clear.c
read_entry.c
tput.c
write_entry.c
-</blockquote></code>
+</code>
+</blockquote>
<P>
The following modules will use open()/read()/write()/close()/lseek() on files,
-but no other OS calls. <P>
+but no other OS calls.
<DL>
<DT>lib_screen.c
Modules that would have to be modified for a port start here: <P>
The following modules are `pure curses' but contain assumptions inappropriate
-for a memory-mapped port. <P>
+for a memory-mapped port.
<dl>
<dt>lib_longname.c<dd>assumes there may be multiple terminals
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 3.0//EN">
<!--
- $From: ncurses-intro.html,v 1.31 1999/05/16 17:02:31 juergen Exp $
+ $From: ncurses-intro.html,v 1.33 2000/03/05 01:06:43 tom Exp $
-->
<HTML>
<HEAD>
and (b) simplicity. For an application that does not require bit-mapped
graphics and multiple fonts, an interface implementation using <CODE>curses</CODE>
will typically be a great deal simpler and less expensive than one using an
-X toolkit. <P>
+X toolkit.
<H2><A NAME="history">A Brief History of Curses</A></H2>
possible to describe multiple video attributes, and colors and to handle far
more unusual terminals than possible with termcap. In the later AT&T
System V releases, <CODE>curses</CODE> evolved to use more facilities and offer
-more capabilities, going far beyond BSD curses in power and flexibility.<P>
+more capabilities, going far beyond BSD curses in power and flexibility.
<H2><A NAME="scope">Scope of This Document</A></H2>
This document describes <CODE>ncurses</CODE>, a free implementation of
the System V <CODE>curses</CODE> API with some clearly marked extensions.
-It includes the following System V curses features: <P>
+It includes the following System V curses features:
<UL>
<LI>Support for multiple screen highlights (BSD curses could only
-handle one `standout' highlight, usually reverse-video). <P>
-<LI>Support for line- and box-drawing using forms characters. <P>
-<LI>Recognition of function keys on input. <P>
-<LI>Color support. <P>
+handle one `standout' highlight, usually reverse-video).
+<LI>Support for line- and box-drawing using forms characters.
+<LI>Recognition of function keys on input.
+<LI>Color support.
<LI>Support for pads (windows of larger than screen size on which the
screen or a subwindow defines a viewport).
</UL>
Finally, this document describes in detail the <A HREF="#menu">menus</A> and <A
HREF="#form">forms</A> extension libraries, also cloned from System V,
which support easy construction and sequences of menus and fill-in
-forms. <P>
+forms.
<H2><A NAME="terminology">Terminology</A></H2>
<DD>
A data structure describing a sub-rectangle of the screen (possibly the
entire screen). You can write to a window as though it were a miniature
-screen, scrolling independently of other windows on the physical screen. <P>
+screen, scrolling independently of other windows on the physical screen.
<DT> screens
<DD>
A subset of windows which are as large as the terminal screen, i.e., they start
at the upper left hand corner and encompass the lower right hand corner. One
-of these, <CODE>stdscr</CODE>, is automatically provided for the programmer. <P>
+of these, <CODE>stdscr</CODE>, is automatically provided for the programmer.
<DT> terminal screen
<DD>
The package's idea of what the terminal display currently looks like, i.e.,
overlapping windows. Also, changes can be made to windows in any order,
without regard to motion efficiency. Then, at will, the programmer can
effectively say ``make it look like this,'' and let the package implementation
-determine the most efficient way to repaint the screen. <P>
+determine the most efficient way to repaint the screen.
<H3><A NAME="stdscr">Standard Windows and Function Naming Conventions</A></H3>
Note that the window description pointer (win) comes before the added (y, x)
coordinates. If a function requires a window pointer, it is always the first
-parameter passed. <P>
+parameter passed.
<H3><A NAME="variables">Variables</A></H3>
work on any window, providing you change the function names and parameters as
mentioned above. <P>
-Here is a sample program to motivate the discussion: <P>
+Here is a sample program to motivate the discussion:
<PRE>
#include <curses.h>
static void finish(int sig);
+int
main(int argc, char *argv[])
{
+ int num = 0;
+
/* initialize your non-curses data structures here */
(void) signal(SIGINT, finish); /* arrange interrupts to terminate */
keypad(stdscr, TRUE); /* enable keyboard mapping */
(void) nonl(); /* tell curses not to do NL->CR/NL on output */
(void) cbreak(); /* take input chars one at a time, no wait for \n */
- (void) noecho(); /* don't echo input */
+ (void) echo(); /* echo input - in color */
if (has_colors())
{
start_color();
/*
- * Simple color assignment, often all we need.
+ * Simple color assignment, often all we need. Color pair 0 cannot
+ * be redefined. This example uses the same value for the color
+ * pair as for the foreground color, though of course that is not
+ * necessary:
*/
- init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK);
- init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
- init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
- init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
- init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
- init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
- init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
- init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
+ init_pair(1, COLOR_RED, COLOR_BLACK);
+ init_pair(2, COLOR_GREEN, COLOR_BLACK);
+ init_pair(3, COLOR_YELLOW, COLOR_BLACK);
+ init_pair(4, COLOR_BLUE, COLOR_BLACK);
+ init_pair(5, COLOR_CYAN, COLOR_BLACK);
+ init_pair(6, COLOR_MAGENTA, COLOR_BLACK);
+ init_pair(7, COLOR_WHITE, COLOR_BLACK);
}
for (;;)
{
int c = getch(); /* refresh, accept single keystroke of input */
+ attrset(COLOR_PAIR(num % 8));
+ num++;
/* process the command keystroke */
}
You can create new windows of your own using the functions <CODE>newwin()</CODE>,
<CODE>derwin()</CODE>, and <CODE>subwin()</CODE>. The routine <CODE>delwin()</CODE> will
allow you to get rid of old windows. All the options described above can be
-applied to any window. <P>
+applied to any window.
<H3><A NAME="output">Output</A></H3>
If you call <CODE>wrefresh()</CODE> with <CODE>curscr</CODE> as its argument, it will
make the screen look like <CODE>curscr</CODE> thinks it looks like. This is useful
for implementing a command which would redraw the screen in case it get messed
-up. <P>
+up.
<H3><A NAME="input">Input</A></H3>
function keys. These sequences are returned as pseudo-character values. The
<CODE>#define</CODE> values returned are listed in the <CODE>curses.h</CODE> The
mapping from sequences to <CODE>#define</CODE> values is determined by
-<CODE>key_</CODE> capabilities in the terminal's terminfo entry. <P>
+<CODE>key_</CODE> capabilities in the terminal's terminfo entry.
<H3><A NAME="formschars">Using Forms Characters</A></H3>
The most useful of the ACS defines are the forms-drawing characters. You can
use these to draw boxes and simple graphs on the screen. If the terminal
does not have such characters, <CODE>curses.h</CODE> will map them to a
-recognizable (though ugly) set of ASCII defaults. <P>
+recognizable (though ugly) set of ASCII defaults.
<H3><A NAME="attributes">Character Attributes and Color</A></H3>
Once you've done an <CODE>init_pair()</CODE> that creates color-pair N, you can
use <CODE>COLOR_PAIR(N)</CODE> as a highlight that invokes that particular
color combination. Note that <CODE>COLOR_PAIR(N)</CODE>, for constant N,
-is itself a compile-time constant and can be used in initializers. <P>
+is itself a compile-time constant and can be used in initializers.
<H3><A NAME="mouse">Mouse Interfacing</A></H3>
code that illustrates how this can be done. <P>
See the manual page <CODE>curs_mouse(3X)</CODE> for full details of the
-mouse-interface functions. <P>
+mouse-interface functions.
<H3><A NAME="finishing">Finishing Up</A></H3>
<CODE>endwin()</CODE> is provided. It restores tty modes to what they were when
<CODE>initscr()</CODE> was first called, and moves the cursor down to the
lower-left corner. Thus, anytime after the call to initscr, <CODE>endwin()</CODE>
-should be called before exiting. <P>
+should be called before exiting.
<H2><A NAME="functions">Function Descriptions</A></H2>
exits. Otherwise it returns a pointer to stdscr. A few functions may be
called before initscr (<CODE>slk_init()</CODE>, <CODE>filter()</CODE>,
<CODE>ripofflines()</CODE>, <CODE>use_env()</CODE>, and, if you are using multiple
-terminals, <CODE>newterm()</CODE>.) <P>
+terminals, <CODE>newterm()</CODE>.)
<DT> <CODE>endwin()</CODE>
<DD> Your program should always call <CODE>endwin()</CODE> before exiting or
shelling out of the program. This function will restore tty modes,
move the cursor to the lower left corner of the screen, reset the
terminal into the proper non-visual mode. Calling <CODE>refresh()</CODE>
or <CODE>doupdate()</CODE> after a temporary escape from the program will
-restore the ncurses screen from before the escape. <P>
+restore the ncurses screen from before the escape.
<DT> <CODE>newterm(type, ofp, ifp)</CODE>
<DD> A program which outputs to more than one terminal should use
<CODE>newterm()</CODE> instead of <CODE>initscr()</CODE>. <CODE>newterm()</CODE> should
<CODE>FILE</CODE> pointers for the output and input of the terminal. If
type is NULL then the environment variable <CODE>$TERM</CODE> is used.
<CODE>endwin()</CODE> should called once at wrapup time for each terminal
-opened using this function. <P>
+opened using this function.
<DT> <CODE>set_term(new)</CODE>
<DD> This function is used to switch to a different terminal previously
opened by <CODE>newterm()</CODE>. The screen reference for the new terminal
is passed as the parameter. The previous terminal is returned by the
-function. All other calls affect only the current terminal. <P>
+function. All other calls affect only the current terminal.
<DT> <CODE>delscreen(sp)</CODE>
<DD> The inverse of <CODE>newterm()</CODE>; deallocates the data structures
associated with a given <CODE>SCREEN</CODE> reference.
there in order to do optimizations. <CODE>refresh()</CODE> does a
refresh of <CODE>stdscr()</CODE>. Unless <CODE>leaveok()</CODE> has been
enabled, the physical cursor of the terminal is left at the
-location of the window's cursor. <P>
+location of the window's cursor.
<DT> <CODE>doupdate()</CODE> and <CODE>wnoutrefresh(win)</CODE>
<DD> These two functions allow multiple updates with more efficiency
than wrefresh. To use them, it is important to understand how curses
included with the <CODE>ncurses</CODE> distribution that can alleviate
this problem somewhat; it compacts long sequences of similar operations into
more succinct single-line pseudo-operations. These pseudo-ops can be
-distinguished by the fact that they are named in capital letters.<P>
+distinguished by the fact that they are named in capital letters.
<H2><A NAME="hints">Hints, Tips, and Tricks</A></H2>
The <CODE>ncurses</CODE> manual pages are a complete reference for this library.
In the remainder of this document, we discuss various useful methods that
-may not be obvious from the manual page descriptions. <P>
+may not be obvious from the manual page descriptions.
<H3><A NAME="caution">Some Notes of Caution</A></H3>
Try to avoid using the global variables LINES and COLS. Use
<CODE>getmaxyx()</CODE> on the <CODE>stdscr</CODE> context instead. Reason:
your code may be ported to run in an environment with window resizes,
-in which case several screens could be open with different sizes. <P>
+in which case several screens could be open with different sizes.
<H3><A NAME="leaving">Temporarily Leaving NCURSES Mode</A></H3>
pointers; each call will return a screen reference, and <CODE>stdscr</CODE> will be
set to the last one allocated. You will switch between screens with the
<CODE>set_term</CODE> call. Note that you will also have to call
-<CODE>def_shell_mode</CODE> and <CODE>def_prog_mode</CODE> on each tty yourself. <P>
+<CODE>def_shell_mode</CODE> and <CODE>def_prog_mode</CODE> on each tty yourself.
<H3><A NAME="testing">Testing for Terminal Capabilities</A></H3>
(cursor-addressable) or `stupid'. The right way to test this is to see
if the return value of <CODE>tigetstr("cup")</CODE> is non-NULL. Alternatively,
you can include the <CODE>term.h</CODE> file and test the value of the
-macro <CODE>cursor_address</CODE>. <P>
+macro <CODE>cursor_address</CODE>.
<H3><A NAME="tuning">Tuning for Speed</A></H3>
Use the <CODE>addchstr()</CODE> family of functions for fast
screen-painting of text when you know the text doesn't contain any
control characters. Try to make attribute changes infrequent on your
-screens. Don't use the <CODE>immedok()</CODE> option! <P>
+screens. Don't use the <CODE>immedok()</CODE> option!
<H3><A NAME="special">Special Features of NCURSES</A></H3>
do all the necessary <CODE>wnoutrfresh()</CODE> calls for whatever panel
stacking order you have defined. Then you can do one <CODE>doupdate()</CODE>
and there will be a <EM>single</EM> burst of physical I/O that will do
-all your updates. <P>
+all your updates.
<H3><A NAME="backbug">Background Erase</A></H3>
or <CODE>wbkgdset()</CODE>. <P>
This change in behavior conforms <CODE>ncurses</CODE> to System V Release 4 and
-the XSI Curses standard. <P>
+the XSI Curses standard.
<H2><A NAME="xsifuncs">XSI Curses Conformance</A></H2>
Also, <CODE>ncurses</CODE> meets the XSI requirement that every macro
entry point have a corresponding function which may be linked (and
will be prototype-checked) if the macro definition is disabled with
-<CODE>#undef</CODE>. <P>
+<CODE>#undef</CODE>.
<H1><A NAME="panels">The Panels Library</A></H1>
<CODE>doupdate()</CODE> just before accepting command input, once in each cycle
of interaction with the user. If you call <CODE>update_panels()</CODE> after
each and every panel write, you'll generate a lot of unnecessary refresh
-activity and screen flicker. <P>
+activity and screen flicker.
<H2><A NAME="pstdscr">Panels, Input, and the Standard Screen</A></H2>
that the panel is totally unobscured. <P>
There is presently no way to display changes to one obscured panel without
-repainting all panels. <P>
+repainting all panels.
<H2><A NAME="hiding">Hiding Panels</A></H2>
The <CODE>panel_update</CODE> code ignores hidden panels. You cannot do
<CODE>top_panel()</CODE> or <CODE>bottom_panel</CODE> on a hidden panel().
-Other panels operations are applicable. <P>
+Other panels operations are applicable.
<H2><A NAME="pmisc">Miscellaneous Other Facilities</A></H2>
Every panel has an associated user pointer, not used by the panel code, to
which you can attach application data. See the man page documentation
of <CODE>set_panel_userptr()</CODE> and <CODE>panel_userptr</CODE> for
-details. <P>
+details.
<H1><A NAME="menu">The Menu Library</A></H1>
The <CODE>menu</CODE> library first appeared in AT&T System V. The
version documented here is the <CODE>menu</CODE> code distributed
-with <CODE>ncurses</CODE>. <P>
+with <CODE>ncurses</CODE>.
<H2><A NAME="mcompile">Compiling With the menu Library</A></H2>
Menu items can be made unselectable using <CODE>set_item_opts()</CODE>
or <CODE>item_opts_off()</CODE> with the <CODE>O_SELECTABLE</CODE>
argument. This is the only option so far defined for menus, but it
-is good practice to code as though other option bits might be on. <P>
+is good practice to code as though other option bits might be on.
<H2><A NAME="mdisplay">Menu Display</A></H2>
The menu library calculates a minimum display size for your window, based
-on the following variables: <P>
+on the following variables:
<UL>
<LI>The number and maximum length of the menu items
an attribute for selectable items, an attribute for unselectable items,
and a pad character used to separate item name text from description
text. These have reasonable defaults which the library allows you to
-change (see the <CODE>menu_attribs(3x)</CODE> manual page. <P>
+change (see the <CODE>menu_attribs(3x)</CODE> manual page.
<H2><A NAME="mwindows">Menu Windows</A></H2>
When you call <CODE>menu_post()</CODE>, you write the menu to its
subwindow. When you call <CODE>menu_unpost()</CODE>, you erase the
subwindow, However, neither of these actually modifies the screen. To
-do that, call <CODE>wrefresh()</CODE> or some equivalent. <P>
+do that, call <CODE>wrefresh()</CODE> or some equivalent.
<H2><A NAME="minput">Processing Menu Input</A></H2>
Each item, and each menu, has an associated user pointer on which you
can hang application data. See <CODE>mitem_userptr(3x)</CODE> and
-<CODE>menu_userptr(3x)</CODE>. <P>
+<CODE>menu_userptr(3x)</CODE>.
<H1><A NAME="form">The Forms Library</A></H1>
The <CODE>form</CODE> library first appeared in AT&T System V. The
version documented here is the <CODE>form</CODE> code distributed
-with <CODE>ncurses</CODE>. <P>
+with <CODE>ncurses</CODE>.
<H2><A NAME="fcompile">Compiling With the form Library</A></H2>
<CODE>-lform</CODE> argument. Note that they must also link the
<CODE>ncurses</CODE> library with <CODE>-lncurses</CODE>. Many linkers
are two-pass and will accept either order, but it is still good practice
-to put <CODE>-lform</CODE> first and <CODE>-lncurses</CODE> second. <P>
+to put <CODE>-lform</CODE> first and <CODE>-lncurses</CODE> second.
<H2><A NAME="foverview">Overview of Forms</A></H2>
In forms programs, however, the `process user requests' is somewhat more
complicated than for menus. Besides menu-like navigation operations,
-the menu driver loop has to support field editing and data validation. <P>
+the menu driver loop has to support field editing and data validation.
<H2><A NAME="fcreate">Creating and Freeing Fields and Forms</A></H2>
-The basic function for creating fields is <CODE>new_field()</CODE>: <P>
+The basic function for creating fields is <CODE>new_field()</CODE>:
<PRE>
FIELD *new_field(int height, int width, /* new field size */
each buffer is <CODE>((height + offscreen)*width + 1</CODE>, one character
for each position in the field plus a NUL terminator. The sixth
argument is the number of additional data buffers to allocate for the
-field; your application can use them for its own purposes. <P>
+field; your application can use them for its own purposes.
<PRE>
FIELD *dup_field(FIELD *field, /* field to copy */
The function <CODE>dup_field()</CODE> duplicates an existing field at a
new location. Size and buffering information are copied; some
attribute flags and status bits are not (see the
-<CODE>form_field_new(3X)</CODE> for details). <P>
+<CODE>form_field_new(3X)</CODE> for details).
<PRE>
FIELD *link_field(FIELD *field, /* field to copy */
the field allocation is not possible due to an out-of-memory error or
out-of-bounds arguments. <P>
-To connect fields to a form, use <P>
+To connect fields to a form, use
<PRE>
FORM *new_form(FIELD **fields);
The functions <CODE>free_field()</CODE> and <CODE>free_form</CODE> are available
to free field and form objects. It is an error to attempt to free a field
connected to a form, but not vice-versa; thus, you will generally free
-your form objects first. <P>
+your form objects first.
<H2><A NAME="fattributes">Fetching and Changing Field Attributes</A></H2>
<CODE>new_field</CODE> function are copied from an invisible system
default field. In attribute-setting and -fetching functions, the
argument NULL is taken to mean this field. Changes to it persist
-as defaults until your forms application terminates. <P>
+as defaults until your forms application terminates.
<H3><A NAME="fsizes">Fetching Size and Location Data</A></H3>
-You can retrieve field sizes and locations through: <P>
+You can retrieve field sizes and locations through:
<PRE>
int field_info(FIELD *field, /* field from which to fetch */
This function is a sort of inverse of <CODE>new_field()</CODE>; instead of
setting size and location attributes of a new field, it fetches them
-from an existing one. <P>
+from an existing one.
<H3><A NAME="flocation">Changing the Field Location</A></H3>
-It is possible to move a field's location on the screen: <P>
+It is possible to move a field's location on the screen:
<PRE>
int move_field(FIELD *field, /* field to alter */
<H3><A NAME="fjust">The Justification Attribute</A></H3>
One-line fields may be unjustified, justified right, justified left,
-or centered. Here is how you manipulate this attribute: <P>
+or centered. Here is how you manipulate this attribute:
<PRE>
int set_field_just(FIELD *field, /* field to alter */
The mode values accepted and returned by this functions are
preprocessor macros <CODE>NO_JUSTIFICATION</CODE>, <CODE>JUSTIFY_RIGHT</CODE>,
-<CODE>JUSTIFY_LEFT</CODE>, or <CODE>JUSTIFY_CENTER</CODE>. <P>
+<CODE>JUSTIFY_LEFT</CODE>, or <CODE>JUSTIFY_CENTER</CODE>.
<H3><A NAME="fdispatts">Field Display Attributes</A></H3>
This group of four field attributes controls the visual appearance
of the field on the screen, without affecting in any way the data
-in the field buffer. <P>
+in the field buffer.
<PRE>
int set_field_fore(FIELD *field, /* field to alter */
<CODE>A_BOLD</CODE>, <CODE>A_REVERSE</CODE> etc).
The page bit of a field controls whether it is displayed at the start of
-a new form screen. <P>
+a new form screen.
<H3><A NAME="foptions">Field Option Bits</A></H3>
However, options may be changed on posted fields that are not current. <P>
The option values are bit-masks and can be composed with logical-or in
-the obvious way. <P>
+the obvious way.
<H2><A NAME="fstatus">Field Status</A></H2>
Every field has a status flag, which is set to FALSE when the field is
created and TRUE when the value in field buffer 0 changes. This flag can
-be queried and set directly: <P>
+be queried and set directly:
<PRE>
int set_field_status(FIELD *field, /* field to alter */
<CODE>field_status()</CODE> either (1) in the field's exit validation check
routine, (2) from the field's or form's initialization or termination
hooks, or (3) just after a <CODE>REQ_VALIDATION</CODE> request has been
-processed by the forms driver. <P>
+processed by the forms driver.
<H2><A NAME="fuser">Field User Pointer</A></H2>
It is valid to set the user pointer of the default field (with a
<CODE>set_field_userptr()</CODE> call passed a NULL field pointer.)
When a new field is created, the default-field user pointer is copied
-to initialize the new field's user pointer. <P>
+to initialize the new field's user pointer.
<H2><A NAME="fdynamic">Variable-Sized Fields</A></H2>
Normally, a dynamic field is allowed to grow without limit. But it is
possible to set an upper limit on the size of a dynamic field. You do
-it with this function: <P>
+it with this function:
<PRE>
int set_max_field(FIELD *field, /* field to alter (may not be NULL) */
The <CODE>form</CODE> library provides a rich set of pre-defined validation
types, and gives you the capability to define custom ones of your own. You
can examine and change field validation attributes with the following
-functions: <P>
+functions:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
<CODE>NULL</CODE> field default will change the system default for validation of
newly-created fields. <P>
-Here are the pre-defined validation types: <P>
+Here are the pre-defined validation types:
<H3><A NAME="ftype_alpha">TYPE_ALPHA</A></H3>
This field type accepts alphabetic data; no blanks, no digits, no special
-characters (this is checked at character-entry time). It is set up with: <P>
+characters (this is checked at character-entry time). It is set up with:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
The <CODE>width</CODE> argument sets a minimum width of data. Typically
you'll want to set this to the field width; if it's greater than the
field width, the validation check will always fail. A minimum width
-of zero makes field completion optional. <P>
+of zero makes field completion optional.
<H3><A NAME="ftype_alnum">TYPE_ALNUM</A></H3>
This field type accepts alphabetic data and digits; no blanks, no special
-characters (this is checked at character-entry time). It is set up with: <P>
+characters (this is checked at character-entry time). It is set up with:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
The <CODE>width</CODE> argument sets a minimum width of data. As with
TYPE_ALPHA, typically you'll want to set this to the field width; if it's
greater than the field width, the validation check will always fail. A
-minimum width of zero makes field completion optional. <P>
+minimum width of zero makes field completion optional.
<H3><A NAME="ftype_enum">TYPE_ENUM</A></H3>
This type allows you to restrict a field's values to be among a specified
set of string values (for example, the two-letter postal codes for U.S.
-states). It is set up with: <P>
+states). It is set up with:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
matches to be unique in order to be valid. <P>
The <CODE>REQ_NEXT_CHOICE</CODE> and <CODE>REQ_PREV_CHOICE</CODE> input requests
-can be particularly useful with these fields. <P>
+can be particularly useful with these fields.
<H3><A NAME="ftype_integer">TYPE_INTEGER</A></H3>
-This field type accepts an integer. It is set up as follows: <P>
+This field type accepts an integer. It is set up as follows:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
<H3><A NAME="ftype_numeric">TYPE_NUMERIC</A></H3>
-This field type accepts a decimal number. It is set up as follows: <P>
+This field type accepts a decimal number. It is set up as follows:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
<H3><A NAME="ftype_regexp">TYPE_REGEXP</A></H3>
This field type accepts data matching a regular expression. It is set up
-as follows: <P>
+as follows:
<PRE>
int set_field_type(FIELD *field, /* field to alter */
The chief attribute of a field is its buffer contents. When a form has
been completed, your application usually needs to know the state of each
-field buffer. You can find this out with: <P>
+field buffer. You can find this out with:
<PRE>
char *field_buffer(FIELD *field, /* field to query */
call <CODE>field_buffer()</CODE> either (1) in the field's exit validation
check routine, (2) from the field's or form's initialization or termination
hooks, or (3) just after a <CODE>REQ_VALIDATION</CODE> request has been processed
-by the forms driver. <P>
+by the forms driver.
<H2><A NAME="formattrs">Attributes of Forms</A></H2>
of these functions using a form-pointer argument of <CODE>NULL</CODE>. <P>
The principal attribute of a form is its field list. You can query
-and change this list with: <P>
+and change this list with:
<PRE>
int set_form_fields(FORM *form, /* form to alter */
The <CODE>field_count()</CODE> function simply counts the number of fields
connected to a given from. It returns -1 if the form-pointer argument
-is NULL. <P>
+is NULL.
<H2><A NAME="fdisplay">Control of Form Display</A></H2>
In order to declare your own frame window for a form, you'll need to
know the size of the form's bounding rectangle. You can get this
-information with: <P>
+information with:
<PRE>
int scale_form(FORM *form, /* form to query */
It is possible to check from your application whether all of a
scrollable field is actually displayed within the menu subwindow. Use
-these functions: <P>
+these functions:
<PRE>
int data_ahead(FORM *form); /* form to be queried */
left hand) character position is off-screen (not being displayed). <P>
Finally, there is a function to restore the form window's cursor to the
-value expected by the forms driver: <P>
+value expected by the forms driver:
<PRE>
int pos_form_cursor(FORM *) /* form to be queried */
</PRE>
If your application changes the form window cursor, call this function before
-handing control back to the forms driver in order to re-synchronize it. <P>
+handing control back to the forms driver in order to re-synchronize it.
<H2><A NAME="fdriver">Input Processing in the Forms Driver</A></H2>
The function <CODE>form_driver()</CODE> handles virtualized input requests
for form navigation, editing, and validation requests, just as
<CODE>menu_driver</CODE> does for menus (see the section on <A
-HREF="#minput">menu input handling</A>). <P>
+HREF="#minput">menu input handling</A>).
<PRE>
int form_driver(FORM *form, /* form to pass input to */
The forms driver provides hooks (through input-validation and
field-termination functions) with which your application code can check
-that the input taken by the driver matched what was expected. <P>
+that the input taken by the driver matched what was expected.
<H3><A NAME="fpage">Page Navigation Requests</A></H3>
These requests cause page-level moves through the form,
-triggering display of a new form screen. <P>
+triggering display of a new form screen.
<DL>
<DT> <CODE>REQ_NEXT_PAGE</CODE>
These requests treat the list as cyclic; that is, <CODE>REQ_NEXT_PAGE</CODE>
from the last page goes to the first, and <CODE>REQ_PREV_PAGE</CODE> from
-the first page goes to the last. <P>
+the first page goes to the last.
<H3><A NAME="#ffield">Inter-Field Navigation Requests</A></H3>
-These requests handle navigation between fields on the same page. <P>
+These requests handle navigation between fields on the same page.
<DL>
<DT> <CODE>REQ_NEXT_FIELD</CODE>
<DD> Move to the first field.
<DT> <CODE>REQ_LAST_FIELD</CODE>
<DD> Move to the last field.
-<P>
<DT> <CODE>REQ_SNEXT_FIELD</CODE>
<DD> Move to sorted next field.
<DT> <CODE>REQ_SPREV_FIELD</CODE>
<DD> Move to the sorted first field.
<DT> <CODE>REQ_SLAST_FIELD</CODE>
<DD> Move to the sorted last field.
-<P>
<DT> <CODE>REQ_LEFT_FIELD</CODE>
<DD> Move left to field.
<DT> <CODE>REQ_RIGHT_FIELD</CODE>
single-line fields A and C on the same line with B, with A to the left
of B and C to the right of B. A <CODE>REQ_MOVE_RIGHT</CODE> from A will
go to B only if A, B, and C <EM>all</EM> share the same first line;
-otherwise it will skip over B to C. <P>
+otherwise it will skip over B to C.
<H3><A NAME="#fifield">Intra-Field Navigation Requests</A></H3>
These requests drive movement of the edit cursor within the currently
-selected field. <P>
+selected field.
<DL>
<DT> <CODE>REQ_NEXT_CHAR</CODE>
Each <EM>word</EM> is separated from the previous and next characters
by whitespace. The commands to move to beginning and end of line or field
-look for the first or last non-pad character in their ranges. <P>
+look for the first or last non-pad character in their ranges.
<H3><A NAME="fscroll">Scrolling Requests</A></H3>
editing and intra-field movement (the library scrolls the field to keep the
cursor visible). It is possible to explicitly request scrolling with the
following requests:
-<P>
<DL>
<DT> <CODE>REQ_SCR_FLINE</CODE>
</DL>
For scrolling purposes, a <EM>page</EM> of a field is the height
-of its visible part. <P>
+of its visible part.
<H3><A NAME="fedit">Editing Requests</A></H3>
(insertion is the default. <P>
The following requests support editing the field and changing the edit
-mode: <P>
+mode:
<DL>
<DT> <CODE>REQ_INS_MODE</CODE>
disabled and the forms driver just returns <CODE>E_REQUEST_DENIED</CODE>. <P>
See <A HREF="#frmoptions">Form Options</A> for discussion of how to set
-and clear the overload options. <P>
+and clear the overload options.
<H3><A NAME="forder">Order Requests</A></H3>
If the type of your field is ordered, and has associated functions
for getting the next and previous values of the type from a given value,
-there are requests that can fetch that value into the field buffer: <P>
+there are requests that can fetch that value into the field buffer:
<DL>
<DT> <CODE>REQ_NEXT_CHOICE</CODE>
Of the built-in field types, only <CODE>TYPE_ENUM</CODE> has built-in successor
and predecessor functions. When you define a field type of your own
(see <A HREF="#fcustom">Custom Validation Types</A>), you can associate
-our own ordering functions. <P>
+our own ordering functions.
<H3><A NAME="fappcmds">Application Commands</A></H3>
Form requests are represented as integers above the <CODE>curses</CODE> value
greater than <CODE>KEY_MAX</CODE> and less than or equal to the constant
<CODE>MAX_COMMAND</CODE>. If your input-virtualization routine returns a
-value above <CODE>MAX_COMMAND</CODE>, the forms driver will ignore it. <P>
+value above <CODE>MAX_COMMAND</CODE>, the forms driver will ignore it.
<H2><A NAME="fhooks">Field Change Hooks</A></H2>
It is possible to set function hooks to be executed whenever the
-current field or form changes. Here are the functions that support this: <P>
+current field or form changes. Here are the functions that support this:
<PRE>
typedef void (*HOOK)(); /* pointer to function returning void */
These functions allow you to either set or query four different hooks.
In each of the set functions, the second argument should be the
address of a hook function. These functions differ only in the timing
-of the hook call. <P>
+of the hook call.
<DL>
<DT> form_init
each field change
<DT> field_term
<DD> This hook is called just after field validation; that is, just before
-the field is altered. It is also called when the form is unposted. <P>
+the field is altered. It is also called when the form is unposted.
<DT> form_term
<DD> This hook is called when the form is unposted; also, just before
each page change operation.
a NULL first argument. <P>
You can disable any of these hooks by (re)setting them to NULL, the default
-value. <P>
+value.
<H2><A HREF="#ffocus">Field Change Commands</A></H2>
input requests. But sometimes it is useful to be able to move the
focus for editing and viewing under control of your application, or
ask which field it currently is in. The following functions help you
-accomplish this: <P>
+accomplish this:
<PRE>
int set_current_field(FORM *form, /* form to alter */
The initial current field of a form is the first active field on the
first page. The function <CODE>set_form_fields()</CODE> resets this.<P>
-It is also possible to move around by pages. <P>
+It is also possible to move around by pages.
<PRE>
int set_form_page(FORM *form, /* form to alter */
</PRE>
The initial page of a newly-created form is 0. The function
-<CODE>set_form_fields()</CODE> resets this. <P>
+<CODE>set_form_fields()</CODE> resets this.
<H2><A NAME="frmoptions">Form Options</A></H2>
Like fields, forms may have control option bits. They can be changed
-or queried with these functions: <P>
+or queried with these functions:
<PRE>
int set_form_opts(FORM *form, /* form to alter */
</DL>
The option values are bit-masks and can be composed with logical-or in
-the obvious way. <P>
+the obvious way.
<H2><A NAME="fcustom">Custom Validation Types</A></H2>
of <CODE>set_field_type</CODE> effectively allow you to parameterize validation
types. Most of the complications in the validation-type interface have to
do with the handling of the additional arguments within custom validation
-functions. <P>
+functions.
<H3><A NAME="flinktypes">Union Types</A></H3>
The simplest way to create a custom data type is to compose it from two
-preexisting ones: <P>
+preexisting ones:
<PRE>
FIELD *link_fieldtype(FIELDTYPE *type1,
for the second. Order functions (see <A HREF="#forder">Order Requests</A>)
associated with the component types will work on the composite; what it does
is check the validation function for the first type, then for the second, to
-figure what type the buffer contents should be treated as. <P>
+figure what type the buffer contents should be treated as.
<H3><A NAME="fnewtypes">New Field Types</A></H3>
To create a field type from scratch, you need to specify one or both of the
-following things: <P>
+following things:
<UL>
<LI>A character-validation function, to check each character as it is entered.
<LI>A field-validation function to be applied on exit from the field.
</UL>
-Here's how you do that: <P>
+Here's how you do that:
<PRE>
typedef int (*HOOK)(); /* pointer to function returning int */
the field. <P>
A character validator gets the character passed in as a first argument.
-It too should return TRUE if the character is valid, FALSE otherwise. <P>
+It too should return TRUE if the character is valid, FALSE otherwise.
<H3><A NAME="fcheckargs">Validation Function Arguments</A></H3>
from the trailing arguments of each <CODE>set_field_type()</CODE> argument, and
a pointer to the pile will be passed to the validation functions. <P>
-Here is how you make the association: <P>
+Here is how you make the association:
<PRE>
typedef char *(*PTRHOOK)(); /* pointer to function returning (char *) */
VOIDHOOK free_str); /* free structure storage */
</PRE>
-Here is how the storage-management hooks are used: <P>
+Here is how the storage-management hooks are used:
<DL>
<DT> <CODE>make_str</CODE>
The <CODE>make_str</CODE> and <CODE>copy_str</CODE> functions may return NULL to
signal allocation failure. The library routines will that call them will
return error indication when this happens. Thus, your validation functions
-should never see a NULL file pointer and need not check specially for it. <P>
+should never see a NULL file pointer and need not check specially for it.
<H3><A NAME="fcustorder">Order Functions For Custom Types</A></H3>
Some custom field types are simply ordered in the same well-defined way
that <CODE>TYPE_ENUM</CODE> is. For such types, it is possible to define
successor and predecessor functions to support the <CODE>REQ_NEXT_CHOICE</CODE>
-and <CODE>REQ_PREV_CHOICE</CODE> requests. Here's how: <P>
+and <CODE>REQ_PREV_CHOICE</CODE> requests. Here's how:
<PRE>
typedef int (*INTHOOK)(); /* pointer to function returning int */
are expected to use the function <CODE>field_buffer()</CODE> to read the
current value, and <CODE>set_field_buffer()</CODE> on buffer 0 to set the next
or previous value. Either hook may return TRUE to indicate success (a
-legal next or previous value was set) or FALSE to indicate failure. <P>
+legal next or previous value was set) or FALSE to indicate failure.
<H3><A NAME="fcustprobs">Avoiding Problems</A></H3>
-/* $OpenBSD: ncurses_cfg.h,v 1.17 2000/02/06 07:10:50 millert Exp $ */
+/* $OpenBSD: ncurses_cfg.h,v 1.18 2000/03/10 01:35:01 millert Exp $ */
/* include/ncurses_cfg.h. Generated automatically by configure. */
/****************************************************************************
#define HAVE_LONG_FILE_NAMES 1
#define HAVE_MEMCCPY 1
#define HAVE_MENU_H 1
+#define HAVE_MKSTEMP 1
#define HAVE_NANOSLEEP 1
#define HAVE_NC_ALLOC_H 1
#define HAVE_PANEL_H 1
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <ctype.h>
#include <tic.h>
-MODULE_ID("$From: comp_scan.c,v 1.37 2000/01/15 21:52:23 tom Exp $")
+MODULE_ID("$From: comp_scan.c,v 1.38 2000/02/13 01:01:26 tom Exp $")
/*
* Maximum length of string capability we'll accept before raising an error.
-/* $OpenBSD: lib_napms.c,v 1.4 2000/02/06 07:10:51 millert Exp $ */
+/* $OpenBSD: lib_napms.c,v 1.5 2000/03/10 01:35:03 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#endif
#endif
-MODULE_ID("$From: lib_napms.c,v 1.7 2000/02/06 01:57:10 tom Exp $")
+MODULE_ID("$From: lib_napms.c,v 1.8 2000/02/13 01:01:26 tom Exp $")
int napms(int ms)
{
-/* $OpenBSD: lib_options.c,v 1.5 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_options.c,v 1.6 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h>
-MODULE_ID("$From: lib_options.c,v 1.37 2000/01/01 16:59:50 tom Exp $")
+MODULE_ID("$From: lib_options.c,v 1.38 2000/02/13 01:01:26 tom Exp $")
int
idlok(WINDOW *win, bool flag)
-/* $OpenBSD: lib_raw.c,v 1.4 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: lib_raw.c,v 1.5 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <curses.priv.h>
#include <term.h> /* cur_term */
-MODULE_ID("$From: lib_raw.c,v 1.6 2000/01/08 17:28:48 tom Exp $")
+MODULE_ID("$From: lib_raw.c,v 1.7 2000/02/13 01:01:26 tom Exp $")
#if defined(SVR4_TERMIO) && !defined(_POSIX_SOURCE)
#define _POSIX_SOURCE
-/* $OpenBSD: lib_setup.c,v 1.8 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_setup.c,v 1.9 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h> /* lines, columns, cur_term */
-MODULE_ID("$From: lib_setup.c,v 1.58 2000/01/01 16:46:57 tom Exp $")
+MODULE_ID("$From: lib_setup.c,v 1.59 2000/02/13 01:01:26 tom Exp $")
/****************************************************************************
*
-/* $OpenBSD: lib_termcap.c,v 1.5 2000/01/16 01:35:18 millert Exp $ */
+/* $OpenBSD: lib_termcap.c,v 1.6 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#define __INTERNAL_CAPS_VISIBLE
#include <term_entry.h>
-MODULE_ID("$From: lib_termcap.c,v 1.35 2000/01/15 20:47:21 tom Exp $")
+MODULE_ID("$From: lib_termcap.c,v 1.36 2000/02/13 01:01:26 tom Exp $")
/*
some of the code in here was contributed by:
-/* $OpenBSD: lib_ti.c,v 1.4 2000/01/16 01:35:18 millert Exp $ */
+/* $OpenBSD: lib_ti.c,v 1.5 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term_entry.h>
#include <tic.h>
-MODULE_ID("$From: lib_ti.c,v 1.19 2000/01/15 20:47:37 tom Exp $")
+MODULE_ID("$From: lib_ti.c,v 1.20 2000/02/13 01:01:26 tom Exp $")
int
tigetflag(NCURSES_CONST char *str)
-/* $OpenBSD: lib_tputs.c,v 1.4 2000/01/16 01:35:18 millert Exp $ */
+/* $OpenBSD: lib_tputs.c,v 1.5 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <termcap.h> /* ospeed */
#include <tic.h>
-MODULE_ID("$From: lib_tputs.c,v 1.43 2000/01/15 20:13:04 tom Exp $")
+MODULE_ID("$From: lib_tputs.c,v 1.45 2000/02/27 02:33:24 tom Exp $")
char PC = 0; /* used by termcap library */
speed_t ospeed = 0; /* used by termcap library */
{
T((T_CALLED("delay_output(%d)"), ms));
- if (no_pad_char)
+ if (no_pad_char) {
+ _nc_flush();
napms(ms);
- else {
+ } else {
register int nullcount;
nullcount = (ms * _nc_baudrate(ospeed)) / 10000;
-/* $OpenBSD: parse_entry.c,v 1.4 2000/01/16 01:35:18 millert Exp $ */
+/* $OpenBSD: parse_entry.c,v 1.5 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#define __INTERNAL_CAPS_VISIBLE
#include <term_entry.h>
-MODULE_ID("$From: parse_entry.c,v 1.41 2000/01/15 22:30:27 tom Exp $")
+MODULE_ID("$From: parse_entry.c,v 1.42 2000/02/13 01:01:26 tom Exp $")
#ifdef LINT
static short const parametrized[] =
-/* $OpenBSD: read_entry.c,v 1.7 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: read_entry.c,v 1.8 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <tic.h>
#include <term_entry.h>
-MODULE_ID("$From: read_entry.c,v 1.65 2000/01/08 18:59:49 tom Exp $")
+MODULE_ID("$From: read_entry.c,v 1.66 2000/02/13 01:01:26 tom Exp $")
#if !HAVE_TELL
#define tell(fd) 0 /* lseek() is POSIX, but not tell() - odd... */
-/* $OpenBSD: read_termcap.c,v 1.4 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: read_termcap.c,v 1.5 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <tic.h>
#include <term_entry.h>
-MODULE_ID("$From: read_termcap.c,v 1.44 2000/01/08 17:27:31 tom Exp $")
+MODULE_ID("$From: read_termcap.c,v 1.45 2000/02/13 01:01:26 tom Exp $")
#ifndef PURE_TERMINFO
-/* $OpenBSD: write_entry.c,v 1.6 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: write_entry.c,v 1.7 2000/03/10 01:35:04 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#define TRACE_OUT(p) /*nothing */
#endif
-MODULE_ID("$From: write_entry.c,v 1.50 2000/01/01 16:35:44 tom Exp $")
+MODULE_ID("$From: write_entry.c,v 1.51 2000/02/13 01:01:26 tom Exp $")
static int total_written;
-/* $OpenBSD: lib_trace.c,v 1.3 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: lib_trace.c,v 1.4 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <ctype.h>
-MODULE_ID("$From: lib_trace.c,v 1.32 2000/01/08 17:37:04 tom Exp $")
+MODULE_ID("$From: lib_trace.c,v 1.33 2000/02/13 01:01:55 tom Exp $")
unsigned _nc_tracing = 0; /* always define this */
-/* $OpenBSD: lib_tracebits.c,v 1.4 2000/01/09 05:06:02 millert Exp $ */
+/* $OpenBSD: lib_tracebits.c,v 1.5 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <curses.priv.h>
#include <term.h> /* cur_term */
-MODULE_ID("$From: lib_tracebits.c,v 1.4 2000/01/08 17:41:41 tom Exp $")
+MODULE_ID("$From: lib_tracebits.c,v 1.5 2000/02/13 01:01:55 tom Exp $")
#if defined(SVR4_TERMIO) && !defined(_POSIX_SOURCE)
#define _POSIX_SOURCE
-/* $OpenBSD: lib_mvcur.c,v 1.5 2000/01/02 22:06:51 millert Exp $ */
+/* $OpenBSD: lib_mvcur.c,v 1.6 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <term.h>
#include <ctype.h>
-MODULE_ID("$From: lib_mvcur.c,v 1.62 2000/01/01 16:54:37 tom Exp $")
+MODULE_ID("$From: lib_mvcur.c,v 1.63 2000/02/13 01:02:34 tom Exp $")
#define STRLEN(s) (s != 0) ? strlen(s) : 0
-/* $OpenBSD: lib_twait.c,v 1.3 2000/02/06 07:10:51 millert Exp $ */
+/* $OpenBSD: lib_twait.c,v 1.4 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
# endif
#endif
-MODULE_ID("$From: lib_twait.c,v 1.35 2000/02/06 01:57:16 tom Exp $")
+MODULE_ID("$From: lib_twait.c,v 1.36 2000/02/13 01:02:34 tom Exp $")
static long _nc_gettime(bool first)
{
-/* $OpenBSD: tty_display.h,v 1.1 1999/01/18 19:10:27 millert Exp $ */
+/* $OpenBSD: tty_display.h,v 1.2 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
* Copyright (c) 1998 Free Software Foundation, Inc. *
vidattr(AttrOf(c));
#endif
-/*
- * Check whether the given character can be output by clearing commands. This
- * includes test for being a space and not including any 'bad' attributes, such
- * as A_REVERSE. All attribute flags which don't affect appearance of a space
- * or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.
- */
-#define can_clear_with(ch) \
- ((ch & ~(NONBLANK_ATTR|(back_color_erase ? A_COLOR:0))) == BLANK)
-
#define XMC_CHANGES(c) ((c) & D->_xmc_suppress)
#endif /* TTY_DISPLAY_H */
-/* $OpenBSD: tty_update.c,v 1.6 2000/02/06 07:10:51 millert Exp $ */
+/* $OpenBSD: tty_update.c,v 1.7 2000/03/10 01:35:05 millert Exp $ */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
****************************************************************************/
-
/*-----------------------------------------------------------------
*
* lib_doupdate.c
#include <term.h>
-MODULE_ID("$From: tty_update.c,v 1.124 2000/02/06 01:57:25 tom Exp $")
+MODULE_ID("$From: tty_update.c,v 1.131 2000/02/26 23:22:11 tom Exp $")
/*
* This define controls the line-breakout optimization. Every once in a
#define CHECK_INTERVAL 5
#define FILL_BCE() (SP->_coloron && !SP->_default_color && !back_color_erase)
+
/*
* Enable checking to see if doupdate and friends are tracking the true
* cursor position correctly. NOTE: this is a debugging hack which will
*/
/* #define POSITION_DEBUG */
-static inline chtype ClrBlank ( WINDOW *win );
+static inline chtype ClrBlank(WINDOW *win);
static int ClrBottom(int total);
-static void ClearScreen( chtype blank );
-static void ClrUpdate( void );
-static void DelChar( int count );
-static void InsStr( chtype *line, int count );
-static void TransformLine( int const lineno );
+static void ClearScreen(chtype blank);
+static void ClrUpdate(void);
+static void DelChar(int count);
+static void InsStr(chtype * line, int count);
+static void TransformLine(int const lineno);
#ifdef POSITION_DEBUG
/****************************************************************************
*
****************************************************************************/
-static void position_check(int expected_y, int expected_x, char *legend)
+static void
+position_check(int expected_y, int expected_x, char *legend)
/* check to see if the real cursor position matches the virtual */
{
- char buf[20];
+ char buf[20];
int y, x;
if (!_nc_tracing || (expected_y < 0 && expected_x < 0))
return;
memset(buf, '\0', sizeof(buf));
- putp("\033[6n"); /* only works on ANSI-compatibles */
+ putp("\033[6n"); /* only works on ANSI-compatibles */
_nc_flush();
- (void) read(0, buf, sizeof(buf)-1);
+ (void) read(0, buf, sizeof(buf) - 1);
_tracef("probe returned %s", _nc_visbuf(buf));
/* try to interpret as a position report */
if (y - 1 != expected_y || x - 1 != expected_x) {
beep();
_tracef("position seen (%d, %d) doesn't match expected one (%d, %d) in %s",
- y-1, x-1, expected_y, expected_x, legend);
+ y - 1, x - 1, expected_y, expected_x, legend);
} else {
_tracef("position matches OK in %s", legend);
}
}
}
#else
-#define position_check(expected_y, expected_x, legend) /* nothing */
+#define position_check(expected_y, expected_x, legend) /* nothing */
#endif /* POSITION_DEBUG */
/****************************************************************************
*
****************************************************************************/
-static inline void GoTo(int const row, int const col)
+static inline void
+GoTo(int const row, int const col)
{
- chtype oldattr = SP->_current_attr;
+ chtype oldattr = SP->_current_attr;
- TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",
- row, col, SP->_cursrow, SP->_curscol));
+ TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",
+ row, col, SP->_cursrow, SP->_curscol));
- position_check(SP->_cursrow, SP->_curscol, "GoTo");
+ position_check(SP->_cursrow, SP->_curscol, "GoTo");
- /*
- * Force restore even if msgr is on when we're in an alternate
- * character set -- these have a strong tendency to screw up the
- * CR & LF used for local character motions!
- */
- if ((oldattr & A_ALTCHARSET)
- || (oldattr && !move_standout_mode))
- {
- TR(TRACE_CHARPUT, ("turning off (%#lx) %s before move",
- oldattr, _traceattr(oldattr)));
- vidattr(A_NORMAL);
- }
+ /*
+ * Force restore even if msgr is on when we're in an alternate
+ * character set -- these have a strong tendency to screw up the
+ * CR & LF used for local character motions!
+ */
+ if ((oldattr & A_ALTCHARSET)
+ || (oldattr && !move_standout_mode)) {
+ TR(TRACE_CHARPUT, ("turning off (%#lx) %s before move",
+ oldattr, _traceattr(oldattr)));
+ vidattr(A_NORMAL);
+ }
- mvcur(SP->_cursrow, SP->_curscol, row, col);
- SP->_cursrow = row;
- SP->_curscol = col;
- position_check(SP->_cursrow, SP->_curscol, "GoTo2");
+ mvcur(SP->_cursrow, SP->_curscol, row, col);
+ SP->_cursrow = row;
+ SP->_curscol = col;
+ position_check(SP->_cursrow, SP->_curscol, "GoTo2");
}
-static inline void PutAttrChar(chtype ch)
+static inline void
+PutAttrChar(chtype ch)
{
- if (tilde_glitch && (TextOf(ch) == '~'))
- ch = ('`' | AttrOf(ch));
-
- TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",
- _tracechtype(ch),
- SP->_cursrow, SP->_curscol));
- UpdateAttrs(ch);
- if (SP->_cleanup) {
- _nc_outch((int)TextOf(ch));
- } else {
- putc((int)TextOf(ch), SP->_ofp); /* macro's fastest... */
+ if (tilde_glitch && (TextOf(ch) == '~'))
+ ch = ('`' | AttrOf(ch));
+
+ TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",
+ _tracechtype(ch),
+ SP->_cursrow, SP->_curscol));
+ UpdateAttrs(ch);
+ if (SP->_cleanup) {
+ _nc_outch((int) TextOf(ch));
+ } else {
+ putc((int) TextOf(ch), SP->_ofp); /* macro's fastest... */
#ifdef TRACE
- _nc_outchars++;
+ _nc_outchars++;
#endif /* TRACE */
- }
- SP->_curscol++;
- if (char_padding) {
- TPUTS_TRACE("char_padding");
- putp(char_padding);
- }
+ }
+ SP->_curscol++;
+ if (char_padding) {
+ TPUTS_TRACE("char_padding");
+ putp(char_padding);
+ }
}
-static bool check_pending(void)
+static bool
+check_pending(void)
/* check for pending input */
{
- bool have_pending = FALSE;
+ bool have_pending = FALSE;
- /*
- * Only carry out this check when the flag is zero, otherwise we'll
- * have the refreshing slow down drastically (or stop) if there's an
- * unread character available.
- */
- if(SP->_fifohold != 0)
- return FALSE;
+ /*
+ * Only carry out this check when the flag is zero, otherwise we'll
+ * have the refreshing slow down drastically (or stop) if there's an
+ * unread character available.
+ */
+ if (SP->_fifohold != 0)
+ return FALSE;
- if (SP->_checkfd >= 0) {
+ if (SP->_checkfd >= 0) {
#if USE_FUNC_POLL
- struct pollfd fds[1];
- fds[0].fd = SP->_checkfd;
- fds[0].events = POLLIN;
- if (poll(fds, 1, 0) > 0)
- {
- have_pending = TRUE;
- }
+ struct pollfd fds[1];
+ fds[0].fd = SP->_checkfd;
+ fds[0].events = POLLIN;
+ if (poll(fds, 1, 0) > 0) {
+ have_pending = TRUE;
+ }
#elif defined(__BEOS__)
- /*
- * BeOS's select() is declared in socket.h, so the configure script does
- * not see it. That's just as well, since that function works only for
- * sockets. This (using snooze and ioctl) was distilled from Be's patch
- * for ncurses which uses a separate thread to simulate select().
- *
- * FIXME: the return values from the ioctl aren't very clear if we get
- * interrupted.
- */
- int n = 0;
- int howmany = ioctl(0, 'ichr', &n);
- if (howmany >= 0 && n > 0) {
- have_pending = TRUE;
- }
+ /*
+ * BeOS's select() is declared in socket.h, so the configure script does
+ * not see it. That's just as well, since that function works only for
+ * sockets. This (using snooze and ioctl) was distilled from Be's patch
+ * for ncurses which uses a separate thread to simulate select().
+ *
+ * FIXME: the return values from the ioctl aren't very clear if we get
+ * interrupted.
+ */
+ int n = 0;
+ int howmany = ioctl(0, 'ichr', &n);
+ if (howmany >= 0 && n > 0) {
+ have_pending = TRUE;
+ }
#elif HAVE_SELECT
- fd_set fdset;
- struct timeval ktimeout;
+ fd_set fdset;
+ struct timeval ktimeout;
- ktimeout.tv_sec =
- ktimeout.tv_usec = 0;
+ ktimeout.tv_sec =
+ ktimeout.tv_usec = 0;
- FD_ZERO(&fdset);
- FD_SET(SP->_checkfd, &fdset);
- if (select(SP->_checkfd+1, &fdset, NULL, NULL, &ktimeout) != 0)
- {
- have_pending = TRUE;
- }
-#endif
- }
- if (have_pending) {
- SP->_fifohold = 5;
- _nc_flush();
+ FD_ZERO(&fdset);
+ FD_SET(SP->_checkfd, &fdset);
+ if (select(SP->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
+ have_pending = TRUE;
}
- return FALSE;
+#endif
+ }
+ if (have_pending) {
+ SP->_fifohold = 5;
+ _nc_flush();
+ }
+ return FALSE;
}
/*
static inline void PutChar(chtype const ch); /* forward declaration */
/* put char at lower right corner */
-static void PutCharLR(chtype const ch)
+static void
+PutCharLR(chtype const ch)
{
- if (!auto_right_margin)
- {
+ if (!auto_right_margin) {
/* we can put the char directly */
PutAttrChar(ch);
- }
- else if (enter_am_mode && exit_am_mode)
- {
+ } else if (enter_am_mode && exit_am_mode) {
/* we can suppress automargin */
TPUTS_TRACE("exit_am_mode");
putp(exit_am_mode);
TPUTS_TRACE("enter_am_mode");
putp(enter_am_mode);
- }
- else if ((enter_insert_mode && exit_insert_mode)
- || insert_character || parm_ich)
- {
- GoTo(screen_lines-1,screen_columns-2);
+ } else if ((enter_insert_mode && exit_insert_mode)
+ || insert_character || parm_ich) {
+ GoTo(screen_lines - 1, screen_columns - 2);
callPutChar(ch);
- GoTo(screen_lines-1,screen_columns-2);
- InsStr(newscr->_line[screen_lines-1].text+screen_columns-2,1);
+ GoTo(screen_lines - 1, screen_columns - 2);
+ InsStr(newscr->_line[screen_lines - 1].text + screen_columns - 2, 1);
}
}
-static void wrap_cursor(void)
+static void
+wrap_cursor(void)
{
- if (eat_newline_glitch)
- {
+ if (eat_newline_glitch) {
/*
* xenl can manifest two different ways. The vt100
* way is that, when you'd expect the cursor to wrap,
*/
SP->_curscol = -1;
SP->_cursrow = -1;
- }
- else if (auto_right_margin)
- {
+ } else if (auto_right_margin) {
SP->_curscol = 0;
SP->_cursrow++;
- }
- else
- {
+ } else {
SP->_curscol--;
}
position_check(SP->_cursrow, SP->_curscol, "wrap_cursor");
}
-static inline void PutChar(chtype const ch)
+static inline void
+PutChar(chtype const ch)
/* insert character, handling automargin stuff */
{
- if (SP->_cursrow == screen_lines-1 && SP->_curscol == screen_columns-1)
+ if (SP->_cursrow == screen_lines - 1 && SP->_curscol == screen_columns - 1)
PutCharLR(ch);
else
PutAttrChar(ch);
position_check(SP->_cursrow, SP->_curscol, "PutChar");
}
+/*
+ * Check whether the given character can be output by clearing commands. This
+ * includes test for being a space and not including any 'bad' attributes, such
+ * as A_REVERSE. All attribute flags which don't affect appearance of a space
+ * or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.
+ */
+static inline bool
+can_clear_with(chtype ch)
+{
+ if (!back_color_erase && SP->_coloron) {
+ if (ch & A_COLOR)
+ return FALSE;
+ if (!SP->_default_color)
+ return FALSE;
+ if (SP->_default_fg != C_MASK || SP->_default_bg != C_MASK)
+ return FALSE;
+ }
+ return ((ch & ~(NONBLANK_ATTR | A_COLOR)) == BLANK);
+}
+
/*
* Issue a given span of characters from an array.
* Must be functionally equivalent to:
*
* This code is optimized using ech and rep.
*/
-static int EmitRange(const chtype *ntext, int num)
+static int
+EmitRange(const chtype * ntext, int num)
{
- int i;
+ int i;
- if (erase_chars || repeat_char)
- {
- while (num > 0)
- {
- int runcount;
+ if (erase_chars || repeat_char) {
+ while (num > 0) {
+ int runcount;
chtype ntext0;
- while (num>1 && ntext[0]!=ntext[1])
- {
+ while (num > 1 && ntext[0] != ntext[1]) {
PutChar(ntext[0]);
ntext++;
num--;
}
ntext0 = ntext[0];
- if (num==1)
- {
+ if (num == 1) {
PutChar(ntext0);
return 0;
}
*/
if (erase_chars
&& runcount > SP->_ech_cost + SP->_cup_cost
- && can_clear_with(ntext0))
- {
+ && can_clear_with(ntext0)) {
UpdateAttrs(ntext0);
putp(tparm(erase_chars, runcount));
GoTo(SP->_cursrow, SP->_curscol + runcount);
else
return 1; /* cursor stays in the middle */
- }
- else if (repeat_char && runcount > SP->_rep_cost)
- {
+ } else if (repeat_char && runcount > SP->_rep_cost) {
bool wrap_possible = (SP->_curscol + runcount >= screen_columns);
int rep_count = runcount;
if (wrap_possible)
PutChar(ntext0);
- }
- else
- {
+ } else {
for (i = 0; i < runcount; i++)
PutChar(ntext[i]);
}
*
* Returns: same as EmitRange
*/
-static int PutRange(
- const chtype *otext,
- const chtype *ntext,
- int row,
- int first, int last)
+static int
+PutRange(
+ const chtype * otext,
+ const chtype * ntext,
+ int row,
+ int first, int last)
{
- int j, run;
- int cost = min(SP->_cup_ch_cost, SP->_hpa_ch_cost);
-
- TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",
- otext, ntext, row, first, last));
-
- if (otext != ntext
- && (last-first+1) > cost) {
- for (j = first, run = 0; j <= last; j++) {
- if (otext[j] == ntext[j]) {
- run++;
- } else {
- if (run > cost) {
- int before_run = (j - run);
- EmitRange(ntext+first, before_run-first);
- GoTo(row, first = j);
- }
- run = 0;
- }
+ int j, run;
+ int cost = min(SP->_cup_ch_cost, SP->_hpa_ch_cost);
+
+ TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",
+ otext, ntext, row, first, last));
+
+ if (otext != ntext
+ && (last - first + 1) > cost) {
+ for (j = first, run = 0; j <= last; j++) {
+ if (otext[j] == ntext[j]) {
+ run++;
+ } else {
+ if (run > cost) {
+ int before_run = (j - run);
+ EmitRange(ntext + first, before_run - first);
+ GoTo(row, first = j);
}
+ run = 0;
+ }
}
- return EmitRange(ntext + first, last-first+1);
+ }
+ return EmitRange(ntext + first, last - first + 1);
}
#if CC_HAS_INLINE_FUNCS
-static void callPutChar(chtype const ch)
+static void
+callPutChar(chtype const ch)
{
- PutChar(ch);
+ PutChar(ch);
}
#endif
+/* leave unbracketed here so 'indent' works */
#define MARK_NOCHANGE(win,row) \
- { \
win->_line[row].firstchar = _NOCHANGE; \
win->_line[row].lastchar = _NOCHANGE; \
- if_USE_SCROLL_HINTS(win->_line[row].oldindex = row); \
- }
+ if_USE_SCROLL_HINTS(win->_line[row].oldindex = row)
-int doupdate(void)
+int
+doupdate(void)
{
-int i;
-int nonempty;
+ int i;
+ int nonempty;
#if USE_TRACE_TIMES
-struct tms before, after;
+ struct tms before, after;
#endif /* USE_TRACE_TIMES */
- T((T_CALLED("doupdate()")));
+ T((T_CALLED("doupdate()")));
#ifdef TRACE
- if (_nc_tracing & TRACE_UPDATE)
- {
- if (curscr->_clear)
- _tracef("curscr is clear");
- else
- _tracedump("curscr", curscr);
- _tracedump("newscr", newscr);
- }
+ if (_nc_tracing & TRACE_UPDATE) {
+ if (curscr->_clear)
+ _tracef("curscr is clear");
+ else
+ _tracedump("curscr", curscr);
+ _tracedump("newscr", newscr);
+ }
#endif /* TRACE */
- _nc_signal_handler(FALSE);
+ _nc_signal_handler(FALSE);
- if (SP->_fifohold)
- SP->_fifohold--;
+ if (SP->_fifohold)
+ SP->_fifohold--;
#if USE_SIZECHANGE
- if (SP->_endwin || SP->_sig_winch)
- {
- /*
- * This is a transparent extension: XSI does not address it,
- * and applications need not know that ncurses can do it.
- *
- * Check if the terminal size has changed while curses was off
- * (this can happen in an xterm, for example), and resize the
- * ncurses data structures accordingly.
- */
- _nc_update_screensize();
- }
+ if (SP->_endwin || SP->_sig_winch) {
+ /*
+ * This is a transparent extension: XSI does not address it,
+ * and applications need not know that ncurses can do it.
+ *
+ * Check if the terminal size has changed while curses was off
+ * (this can happen in an xterm, for example), and resize the
+ * ncurses data structures accordingly.
+ */
+ _nc_update_screensize();
+ }
#endif
- if (SP->_endwin) {
+ if (SP->_endwin) {
- T(("coming back from shell mode"));
- reset_prog_mode();
+ T(("coming back from shell mode"));
+ reset_prog_mode();
- _nc_mvcur_resume();
- _nc_screen_resume();
- SP->_mouse_resume(SP);
-
- SP->_endwin = FALSE;
- }
+ _nc_mvcur_resume();
+ _nc_screen_resume();
+ SP->_mouse_resume(SP);
+ SP->_endwin = FALSE;
+ }
#if USE_TRACE_TIMES
- /* zero the metering machinery */
- _nc_outchars = 0;
- (void) times(&before);
+ /* zero the metering machinery */
+ _nc_outchars = 0;
+ (void) times(&before);
#endif /* USE_TRACE_TIMES */
- /*
- * This is the support for magic-cookie terminals. The
- * theory: we scan the virtual screen looking for attribute
- * turnons. Where we find one, check to make sure it's
- * realizable by seeing if the required number of
- * un-attributed blanks are present before and after the
- * attributed range; try to shift the range boundaries over
- * blanks (not changing the screen display) so this becomes
- * true. If it is, shift the beginning attribute change
- * appropriately (the end one, if we've gotten this far, is
- * guaranteed room for its cookie). If not, nuke the added
- * attributes out of the span.
- */
+ /*
+ * This is the support for magic-cookie terminals. The
+ * theory: we scan the virtual screen looking for attribute
+ * turnons. Where we find one, check to make sure it's
+ * realizable by seeing if the required number of
+ * un-attributed blanks are present before and after the
+ * attributed range; try to shift the range boundaries over
+ * blanks (not changing the screen display) so this becomes
+ * true. If it is, shift the beginning attribute change
+ * appropriately (the end one, if we've gotten this far, is
+ * guaranteed room for its cookie). If not, nuke the added
+ * attributes out of the span.
+ */
#if USE_XMC_SUPPORT
- if (magic_cookie_glitch > 0) {
- int j, k;
- attr_t rattr = A_NORMAL;
-
- for (i = 0; i < screen_lines; i++)
- for (j = 0; j < screen_columns; j++)
- {
- bool failed = FALSE;
- chtype turnon = AttrOf(newscr->_line[i].text[j]) & ~rattr;
-
- /* is an attribute turned on here? */
- if (turnon == 0) {
- rattr = AttrOf(newscr->_line[i].text[j]);
- continue;
- }
+ if (magic_cookie_glitch > 0) {
+ int j, k;
+ attr_t rattr = A_NORMAL;
- T(("At (%d, %d): from %s...", i, j, _traceattr(rattr)));
- T(("...to %s",_traceattr(turnon)));
+ for (i = 0; i < screen_lines; i++) {
+ for (j = 0; j < screen_columns; j++) {
+ bool failed = FALSE;
+ chtype turnon = AttrOf(newscr->_line[i].text[j]) & ~rattr;
- /*
- * If the attribute change location is a blank with a
- * "safe" attribute, undo the attribute turnon. This may
- * ensure there's enough room to set the attribute before
- * the first non-blank in the run.
- */
-#define SAFE(a) !((a) & (chtype)~NONBLANK_ATTR)
- if (TextOf(newscr->_line[i].text[j])==' ' && SAFE(turnon))
- {
- newscr->_line[i].text[j] &= ~turnon;
- continue;
- }
+ /* is an attribute turned on here? */
+ if (turnon == 0) {
+ rattr = AttrOf(newscr->_line[i].text[j]);
+ continue;
+ }
- /* check that there's enough room at start of span */
- for (k = 1; k <= magic_cookie_glitch; k++)
- if (j-k < 0
- || TextOf(newscr->_line[i].text[j-k]) != ' '
- || !SAFE(AttrOf(newscr->_line[i].text[j-k])))
- failed = TRUE;
- if (!failed)
- {
- bool end_onscreen = FALSE;
- int m, n = j;
-
- /* find end of span, if it's onscreen */
- for (m = i; m < screen_lines; m++)
- {
- for ( ; n < screen_columns; n++)
- {
- if (AttrOf(newscr->_line[m].text[n]) == rattr)
- {
- end_onscreen = TRUE;
- T(("Range attributed with %s ends at (%d, %d)",
- _traceattr(turnon),m,n));
- goto foundit;
- }
- }
- n = 0;
- }
- T(("Range attributed with %s ends offscreen",
- _traceattr(turnon)));
- foundit:;
-
- if (end_onscreen)
- {
- chtype *lastline = newscr->_line[m].text;
-
- /*
- * If there are safely-attributed blanks at the
- * end of the range, shorten the range. This will
- * help ensure that there is enough room at end
- * of span.
- */
- while (n >= 0
- && TextOf(lastline[n]) == ' '
- && SAFE(AttrOf(lastline[n])))
- lastline[n--] &= ~turnon;
-
- /* check that there's enough room at end of span */
- for (k = 1; k <= magic_cookie_glitch; k++)
- if (n + k >= screen_columns
- || TextOf(lastline[n + k]) != ' '
- || !SAFE(AttrOf(lastline[n+k])))
- failed = TRUE;
- }
- }
+ T(("At (%d, %d): from %s...", i, j, _traceattr(rattr)));
+ T(("...to %s", _traceattr(turnon)));
+
+ /*
+ * If the attribute change location is a blank with a
+ * "safe" attribute, undo the attribute turnon. This may
+ * ensure there's enough room to set the attribute before
+ * the first non-blank in the run.
+ */
+#define SAFE(a) (!((a) & (chtype)~NONBLANK_ATTR))
+ if (TextOf(newscr->_line[i].text[j]) == ' ' && SAFE(turnon)) {
+ newscr->_line[i].text[j] &= ~turnon;
+ continue;
+ }
- if (failed)
- {
- int p, q = j;
-
- T(("Clearing %s beginning at (%d, %d)",
- _traceattr(turnon), i, j));
-
- /* turn off new attributes over span */
- for (p = i; p < screen_lines; p++)
- {
- for ( ; q < screen_columns; q++)
- {
- if (AttrOf(newscr->_line[p].text[q]) == rattr)
- goto foundend;
- newscr->_line[p].text[q] &= ~turnon;
+ /* check that there's enough room at start of span */
+ for (k = 1; k <= magic_cookie_glitch; k++) {
+ if (j - k < 0
+ || TextOf(newscr->_line[i].text[j - k]) != ' '
+ || !SAFE(AttrOf(newscr->_line[i].text[j - k])))
+ failed = TRUE;
+ }
+ if (!failed) {
+ bool end_onscreen = FALSE;
+ int m, n = j;
+
+ /* find end of span, if it's onscreen */
+ for (m = i; m < screen_lines; m++) {
+ for (; n < screen_columns; n++) {
+ if (AttrOf(newscr->_line[m].text[n]) == rattr) {
+ end_onscreen = TRUE;
+ T(("Range attributed with %s ends at (%d, %d)",
+ _traceattr(turnon), m, n));
+ goto foundit;
}
- q = 0;
}
- foundend:;
+ n = 0;
}
- else
- {
- T(("Cookie space for %s found before (%d, %d)",
- _traceattr(turnon), i, j));
+ T(("Range attributed with %s ends offscreen",
+ _traceattr(turnon)));
+ foundit:;
+
+ if (end_onscreen) {
+ chtype *lastline = newscr->_line[m].text;
/*
- * back up the start of range so there's room
- * for cookies before the first nonblank character
+ * If there are safely-attributed blanks at the
+ * end of the range, shorten the range. This will
+ * help ensure that there is enough room at end
+ * of span.
*/
+ while (n >= 0
+ && TextOf(lastline[n]) == ' '
+ && SAFE(AttrOf(lastline[n])))
+ lastline[n--] &= ~turnon;
+
+ /* check that there's enough room at end of span */
for (k = 1; k <= magic_cookie_glitch; k++)
- newscr->_line[i].text[j-k] |= turnon;
+ if (n + k >= screen_columns
+ || TextOf(lastline[n + k]) != ' '
+ || !SAFE(AttrOf(lastline[n + k])))
+ failed = TRUE;
}
+ }
- rattr = AttrOf(newscr->_line[i].text[j]);
+ if (failed) {
+ int p, q = j;
+
+ T(("Clearing %s beginning at (%d, %d)",
+ _traceattr(turnon), i, j));
+
+ /* turn off new attributes over span */
+ for (p = i; p < screen_lines; p++) {
+ for (; q < screen_columns; q++) {
+ if (AttrOf(newscr->_line[p].text[q]) == rattr)
+ goto foundend;
+ newscr->_line[p].text[q] &= ~turnon;
+ }
+ q = 0;
+ }
+ foundend:;
+ } else {
+ T(("Cookie space for %s found before (%d, %d)",
+ _traceattr(turnon), i, j));
+
+ /*
+ * back up the start of range so there's room
+ * for cookies before the first nonblank character
+ */
+ for (k = 1; k <= magic_cookie_glitch; k++)
+ newscr->_line[i].text[j - k] |= turnon;
}
-#ifdef TRACE
- /* show altered highlights after magic-cookie check */
- if (_nc_tracing & TRACE_UPDATE)
- {
- _tracef("After magic-cookie check...");
- _tracedump("newscr", newscr);
+ rattr = AttrOf(newscr->_line[i].text[j]);
}
-#endif /* TRACE */
}
-#endif /* USE_XMC_SUPPORT */
-
- nonempty = 0;
- if (curscr->_clear || newscr->_clear) { /* force refresh ? */
- T(("clearing and updating from scratch"));
- ClrUpdate();
- curscr->_clear = FALSE; /* reset flag */
- newscr->_clear = FALSE; /* reset flag */
- } else {
- int changedlines = CHECK_INTERVAL;
- if(check_pending())
- goto cleanup;
+#ifdef TRACE
+ /* show altered highlights after magic-cookie check */
+ if (_nc_tracing & TRACE_UPDATE) {
+ _tracef("After magic-cookie check...");
+ _tracedump("newscr", newscr);
+ }
+#endif /* TRACE */
+ }
+#endif /* USE_XMC_SUPPORT */
- nonempty = min(screen_lines, newscr->_maxy+1);
+ nonempty = 0;
+ if (curscr->_clear || newscr->_clear) { /* force refresh ? */
+ T(("clearing and updating from scratch"));
+ ClrUpdate();
+ curscr->_clear = FALSE; /* reset flag */
+ newscr->_clear = FALSE; /* reset flag */
+ } else {
+ int changedlines = CHECK_INTERVAL;
- if (SP->_scrolling) {
- _nc_scroll_optimize();
- }
+ if (check_pending())
+ goto cleanup;
- nonempty = ClrBottom(nonempty);
+ nonempty = min(screen_lines, newscr->_maxy + 1);
- T(("Transforming lines, nonempty %d", nonempty));
- for (i = 0; i < nonempty; i++) {
- /*
- * Here is our line-breakout optimization.
- */
- if (changedlines == CHECK_INTERVAL)
- {
- if (check_pending())
- goto cleanup;
- changedlines = 0;
- }
+ if (SP->_scrolling) {
+ _nc_scroll_optimize();
+ }
- /*
- * newscr->line[i].firstchar is normally set
- * by wnoutrefresh. curscr->line[i].firstchar
- * is normally set by _nc_scroll_window in the
- * vertical-movement optimization code,
- */
- if (newscr->_line[i].firstchar != _NOCHANGE
- || curscr->_line[i].firstchar != _NOCHANGE)
- {
- TransformLine(i);
- changedlines++;
- }
+ nonempty = ClrBottom(nonempty);
- /* mark line changed successfully */
- if (i <= newscr->_maxy)
- MARK_NOCHANGE(newscr,i)
- if (i <= curscr->_maxy)
- MARK_NOCHANGE(curscr,i)
- }
+ T(("Transforming lines, nonempty %d", nonempty));
+ for (i = 0; i < nonempty; i++) {
+ /*
+ * Here is our line-breakout optimization.
+ */
+ if (changedlines == CHECK_INTERVAL) {
+ if (check_pending())
+ goto cleanup;
+ changedlines = 0;
+ }
+
+ /*
+ * newscr->line[i].firstchar is normally set
+ * by wnoutrefresh. curscr->line[i].firstchar
+ * is normally set by _nc_scroll_window in the
+ * vertical-movement optimization code,
+ */
+ if (newscr->_line[i].firstchar != _NOCHANGE
+ || curscr->_line[i].firstchar != _NOCHANGE) {
+ TransformLine(i);
+ changedlines++;
+ }
+
+ /* mark line changed successfully */
+ if (i <= newscr->_maxy) {
+ MARK_NOCHANGE(newscr, i)
+ }
+ if (i <= curscr->_maxy) {
+ MARK_NOCHANGE(curscr, i)
+ }
}
+ }
- /* put everything back in sync */
- for (i = nonempty; i <= newscr->_maxy; i++)
- MARK_NOCHANGE(newscr,i)
- for (i = nonempty; i <= curscr->_maxy; i++)
- MARK_NOCHANGE(curscr,i)
+ /* put everything back in sync */
+ for (i = nonempty; i <= newscr->_maxy; i++) {
+ MARK_NOCHANGE(newscr, i)
+ }
+ for (i = nonempty; i <= curscr->_maxy; i++) {
+ MARK_NOCHANGE(curscr, i)
+ }
- if (!newscr->_leaveok)
- {
- curscr->_curx = newscr->_curx;
- curscr->_cury = newscr->_cury;
+ if (!newscr->_leaveok) {
+ curscr->_curx = newscr->_curx;
+ curscr->_cury = newscr->_cury;
- GoTo(curscr->_cury, curscr->_curx);
- }
+ GoTo(curscr->_cury, curscr->_curx);
+ }
- cleanup:
- /*
- * Keep the physical screen in normal mode in case we get other
- * processes writing to the screen.
- */
- UpdateAttrs(A_NORMAL);
+ cleanup:
+ /*
+ * Keep the physical screen in normal mode in case we get other
+ * processes writing to the screen.
+ */
+ UpdateAttrs(A_NORMAL);
- _nc_flush();
- curscr->_attrs = newscr->_attrs;
-/* curscr->_bkgd = newscr->_bkgd; */
+ _nc_flush();
+ curscr->_attrs = newscr->_attrs;
#if USE_TRACE_TIMES
- (void) times(&after);
- TR(TRACE_TIMES, ("Update cost: %ld chars, %ld clocks system time, %ld clocks user time",
+ (void) times(&after);
+ TR(TRACE_TIMES,
+ ("Update cost: %ld chars, %ld clocks system time, %ld clocks user time",
_nc_outchars,
- after.tms_stime-before.tms_stime,
- after.tms_utime-before.tms_utime));
+ after.tms_stime - before.tms_stime,
+ after.tms_utime - before.tms_utime));
#endif /* USE_TRACE_TIMES */
- _nc_signal_handler(TRUE);
+ _nc_signal_handler(TRUE);
- returnCode(OK);
+ returnCode(OK);
}
/*
#define BCE_ATTRS (A_NORMAL|A_COLOR)
#define BCE_BKGD(win) (((win) == curscr ? stdscr : (win))->_bkgd)
-static inline chtype ClrBlank (WINDOW *win)
+static inline chtype
+ClrBlank(WINDOW *win)
{
-chtype blank = BLANK;
- if (back_color_erase)
- blank |= (BCE_BKGD(win) & BCE_ATTRS);
- return blank;
+ chtype blank = BLANK;
+ if (back_color_erase)
+ blank |= (BCE_BKGD(win) & BCE_ATTRS);
+ return blank;
}
/*
**
*/
-static void ClrUpdate(void)
+static void
+ClrUpdate(void)
{
- int i;
- chtype blank = ClrBlank(stdscr);
- int nonempty = min(screen_lines, newscr->_maxy+1);
+ int i;
+ chtype blank = ClrBlank(stdscr);
+ int nonempty = min(screen_lines, newscr->_maxy + 1);
- T(("ClrUpdate() called"));
+ T(("ClrUpdate() called"));
- ClearScreen(blank);
+ ClearScreen(blank);
- T(("updating screen from scratch"));
+ T(("updating screen from scratch"));
- nonempty = ClrBottom(nonempty);
+ nonempty = ClrBottom(nonempty);
- for (i = 0; i < nonempty; i++)
- TransformLine(i);
+ for (i = 0; i < nonempty; i++)
+ TransformLine(i);
}
/*
** Clear to end of current line, starting at the cursor position
*/
-static void ClrToEOL(chtype blank)
+static void
+ClrToEOL(chtype blank)
{
-int j;
-bool needclear = FALSE;
+ int j;
+ bool needclear = FALSE;
- for (j = SP->_curscol; j < screen_columns; j++)
- {
- chtype *cp = &(curscr->_line[SP->_cursrow].text[j]);
+ for (j = SP->_curscol; j < screen_columns; j++) {
+ chtype *cp = &(curscr->_line[SP->_cursrow].text[j]);
- if (*cp != blank)
- {
- *cp = blank;
- needclear = TRUE;
- }
+ if (*cp != blank) {
+ *cp = blank;
+ needclear = TRUE;
}
+ }
- if (needclear)
- {
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_eol");
- if (SP->_el_cost > (screen_columns - SP->_curscol)
-#ifdef NCURSES_EXT_FUNCS
- || FILL_BCE()
-#endif
- )
- {
- int count = (screen_columns - SP->_curscol);
- while (count-- > 0)
- PutChar(blank);
- }
- else
- putp(clr_eol);
- }
+ if (needclear) {
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_eol");
+ if (SP->_el_cost > (screen_columns - SP->_curscol)) {
+ int count = (screen_columns - SP->_curscol);
+ while (count-- > 0)
+ PutChar(blank);
+ } else
+ putp(clr_eol);
+ }
}
/*
** Clear to end of screen, starting at the cursor position
*/
-static void ClrToEOS(chtype blank)
+static void
+ClrToEOS(chtype blank)
{
-int row, col;
+ int row, col;
- row = SP->_cursrow;
- col = SP->_curscol;
+ row = SP->_cursrow;
+ col = SP->_curscol;
-#ifdef NCURSES_EXT_FUNCS
- if (FILL_BCE()) {
- int i, j, k = col;
- for (i = row; i < screen_lines; i++) {
- GoTo(i, k);
- UpdateAttrs(blank);
- for (j = k; j < screen_columns; j++)
- PutChar(blank);
- k = 0;
- }
- GoTo(row, col);
- } else
-#endif
- {
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_eos");
- tputs(clr_eos, screen_lines-row, _nc_outch);
- }
+ {
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_eos");
+ tputs(clr_eos, screen_lines - row, _nc_outch);
+ }
- while (col < screen_columns)
- curscr->_line[row].text[col++] = blank;
+ while (col < screen_columns)
+ curscr->_line[row].text[col++] = blank;
- for (row++; row < screen_lines; row++)
- {
- for (col = 0; col < screen_columns; col++)
- curscr->_line[row].text[col] = blank;
- }
+ for (row++; row < screen_lines; row++) {
+ for (col = 0; col < screen_columns; col++)
+ curscr->_line[row].text[col] = blank;
+ }
}
/*
* screen-update. Do this by scanning backwards through the lines in the
* screen, checking if each is blank, and one or more are changed.
*/
-static int ClrBottom(int total)
+static int
+ClrBottom(int total)
{
-static chtype *tstLine;
-static size_t lenLine;
-
-int row, col;
-int top = total;
-int last = min(screen_columns, newscr->_maxx+1);
-size_t length = sizeof(chtype) * last;
-chtype blank = newscr->_line[total-1].text[last-1]; /* lower right char */
-
- if(!clr_eos || !can_clear_with(blank))
- return total;
-
- if ((tstLine == 0) || (last > (int)lenLine)) {
- tstLine = typeRealloc(chtype, last, tstLine);
- if (tstLine != 0) {
- lenLine = last;
- for (col = 0; col < last; col++)
- tstLine[col] = blank;
- }
- }
+ static chtype *tstLine;
+ static size_t lenLine;
- if (tstLine != 0) {
- for (row = total-1; row >= 0; row--) {
- if (memcmp(tstLine, newscr->_line[row].text, length))
- break;
- if (memcmp(tstLine, curscr->_line[row].text, length))
- top = row;
- }
+ int row;
+ size_t col;
+ int top = total;
+ int last = min(screen_columns, newscr->_maxx + 1);
+ size_t length = sizeof(chtype) * last;
+ chtype blank = newscr->_line[total - 1].text[last - 1]; /* lower right char */
- /* don't use clr_eos for just one line if clr_eol available */
- if (top < total-1 || (top < total && !clr_eol && !clr_bol)) {
- GoTo(top,0);
- ClrToEOS(blank);
- total = top;
- if (SP->oldhash && SP->newhash)
- {
- for (row = top; row < screen_lines; row++)
- SP->oldhash[row] = SP->newhash[row];
- }
- }
+ if (!clr_eos || !can_clear_with(blank))
+ return total;
+
+ if ((tstLine == 0) || (last > (int) lenLine)) {
+ tstLine = typeRealloc(chtype, last, tstLine);
+ if (tstLine == 0)
+ return total;
+ lenLine = last;
+ tstLine[0] = ~blank; /* force the fill below */
+ }
+ if (tstLine[0] != blank) {
+ for (col = 0; col < lenLine; col++)
+ tstLine[col] = blank;
+ }
+
+ for (row = total - 1; row >= 0; row--) {
+ if (memcmp(tstLine, newscr->_line[row].text, length))
+ break;
+ if (memcmp(tstLine, curscr->_line[row].text, length))
+ top = row;
+ }
+
+ /* don't use clr_eos for just one line if clr_eol available */
+ if (top < total - 1 || (top < total && !clr_eol && !clr_bol)) {
+ GoTo(top, 0);
+ ClrToEOS(blank);
+ total = top;
+ if (SP->oldhash && SP->newhash) {
+ for (row = top; row < screen_lines; row++)
+ SP->oldhash[row] = SP->newhash[row];
}
+ }
#if NO_LEAKS
- if (tstLine != 0) {
- FreeAndNull(tstLine);
- }
+ if (tstLine != 0) {
+ FreeAndNull(tstLine);
+ }
#endif
- return total;
+ return total;
}
-
/*
** TransformLine(lineno)
**
** delete oLastChar - nLastChar spaces
*/
-static void TransformLine(int const lineno)
+static void
+TransformLine(int const lineno)
{
-int firstChar, oLastChar, nLastChar;
-chtype *newLine = newscr->_line[lineno].text;
-chtype *oldLine = curscr->_line[lineno].text;
-int n;
-bool attrchanged = FALSE;
-
- T(("TransformLine(%d) called", lineno));
-
- /* copy new hash value to old one */
- if (SP->oldhash && SP->newhash)
- SP->oldhash[lineno] = SP->newhash[lineno];
-
- if(ceol_standout_glitch && clr_eol) {
- firstChar = 0;
- while(firstChar < screen_columns) {
- if(AttrOf(newLine[firstChar]) != AttrOf(oldLine[firstChar]))
- attrchanged = TRUE;
- firstChar++;
- }
- }
+ int firstChar, oLastChar, nLastChar;
+ chtype *newLine = newscr->_line[lineno].text;
+ chtype *oldLine = curscr->_line[lineno].text;
+ int n;
+ bool attrchanged = FALSE;
+
+ T(("TransformLine(%d) called", lineno));
+
+ /* copy new hash value to old one */
+ if (SP->oldhash && SP->newhash)
+ SP->oldhash[lineno] = SP->newhash[lineno];
+ if (ceol_standout_glitch && clr_eol) {
firstChar = 0;
+ while (firstChar < screen_columns) {
+ if (AttrOf(newLine[firstChar]) != AttrOf(oldLine[firstChar]))
+ attrchanged = TRUE;
+ firstChar++;
+ }
+ }
- if (attrchanged) { /* we may have to disregard the whole line */
- GoTo(lineno, firstChar);
- ClrToEOL(ClrBlank(curscr));
- PutRange(oldLine, newLine, lineno, 0, (screen_columns-1));
+ firstChar = 0;
+
+ if (attrchanged) { /* we may have to disregard the whole line */
+ GoTo(lineno, firstChar);
+ ClrToEOL(ClrBlank(curscr));
+ PutRange(oldLine, newLine, lineno, 0, (screen_columns - 1));
#if USE_XMC_SUPPORT
#define NEW(r,c) newscr->_line[r].text[c]
* will work properly only once, since we may overwrite a cookie in a
* following operation.
*/
- } else if (magic_cookie_glitch > 0) {
- GoTo(lineno, firstChar);
- for (n = 0; n < screen_columns; n++) {
- int m = n + magic_cookie_glitch;
-
- /* check for turn-on:
- * If we are writing an attributed blank, where the
- * previous cell is not attributed.
- */
- if (TextOf(newLine[n]) == ' '
- && ((n > 0
- && xmc_turn_on(newLine[n-1], newLine[n]))
- || (n == 0
- && lineno > 0
- && xmc_turn_on(NEW(lineno-1,screen_columns-1), newLine[n])))) {
- n = m;
- }
+ } else if (magic_cookie_glitch > 0) {
+ GoTo(lineno, firstChar);
+ for (n = 0; n < screen_columns; n++) {
+ int m = n + magic_cookie_glitch;
+
+ /* check for turn-on:
+ * If we are writing an attributed blank, where the
+ * previous cell is not attributed.
+ */
+ if (TextOf(newLine[n]) == ' '
+ && ((n > 0
+ && xmc_turn_on(newLine[n - 1], newLine[n]))
+ || (n == 0
+ && lineno > 0
+ && xmc_turn_on(NEW(lineno - 1, screen_columns - 1),
+ newLine[n])))) {
+ n = m;
+ }
- PutChar(newLine[n]);
+ PutChar(newLine[n]);
- /* check for turn-off:
- * If we are writing an attributed non-blank, where the
- * next cell is blank, and not attributed.
- */
- if (TextOf(newLine[n]) != ' '
- && ((n+1 < screen_columns
- && xmc_turn_off(newLine[n], newLine[n+1]))
- || (n+1 >= screen_columns
- && lineno+1 < screen_lines
- && xmc_turn_off(newLine[n], NEW(lineno+1,0))))) {
- n = m;
- }
+ /* check for turn-off:
+ * If we are writing an attributed non-blank, where the
+ * next cell is blank, and not attributed.
+ */
+ if (TextOf(newLine[n]) != ' '
+ && ((n + 1 < screen_columns
+ && xmc_turn_off(newLine[n], newLine[n + 1]))
+ || (n + 1 >= screen_columns
+ && lineno + 1 < screen_lines
+ && xmc_turn_off(newLine[n], NEW(lineno + 1, 0))))) {
+ n = m;
+ }
- }
+ }
#undef NEW
#endif
- } else {
- chtype blank;
+ } else {
+ chtype blank;
+
+ /* find the first differing character */
+ while (firstChar < screen_columns &&
+ newLine[firstChar] == oldLine[firstChar])
+ firstChar++;
+
+ /* if there wasn't one, we're done */
+ if (firstChar >= screen_columns)
+ return;
+
+ /* it may be cheap to clear leading whitespace with clr_bol */
+ if (clr_bol && can_clear_with(blank = newLine[0])) {
+ int oFirstChar, nFirstChar;
+
+ for (oFirstChar = 0; oFirstChar < screen_columns; oFirstChar++)
+ if (oldLine[oFirstChar] != blank)
+ break;
+ for (nFirstChar = 0; nFirstChar < screen_columns; nFirstChar++)
+ if (newLine[nFirstChar] != blank)
+ break;
+
+ if (nFirstChar > oFirstChar + SP->_el1_cost) {
+ if (nFirstChar >= screen_columns && SP->_el_cost <= SP->_el1_cost) {
+ GoTo(lineno, 0);
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_eol");
+ putp(clr_eol);
+ } else {
+ GoTo(lineno, nFirstChar - 1);
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_bol");
+ putp(clr_bol);
+ }
- /* find the first differing character */
- while (firstChar < screen_columns &&
- newLine[firstChar] == oldLine[firstChar])
- firstChar++;
+ while (firstChar < nFirstChar)
+ oldLine[firstChar++] = blank;
- /* if there wasn't one, we're done */
if (firstChar >= screen_columns)
- return;
-
- /* it may be cheap to clear leading whitespace with clr_bol */
- if (clr_bol && can_clear_with(blank=newLine[0]))
- {
- int oFirstChar, nFirstChar;
-
- for (oFirstChar = 0; oFirstChar < screen_columns; oFirstChar++)
- if (oldLine[oFirstChar] != blank)
- break;
- for (nFirstChar = 0; nFirstChar < screen_columns; nFirstChar++)
- if (newLine[nFirstChar] != blank)
- break;
-
- if (nFirstChar > oFirstChar + SP->_el1_cost)
- {
- if (nFirstChar >= screen_columns && SP->_el_cost <= SP->_el1_cost)
- {
- GoTo(lineno, 0);
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_eol");
- putp(clr_eol);
- }
- else
- {
- GoTo(lineno, nFirstChar - 1);
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_bol");
- putp(clr_bol);
- }
-
- while (firstChar < nFirstChar)
- oldLine[firstChar++] = blank;
-
- if (firstChar >= screen_columns)
- return;
- }
- }
+ return;
+ }
+ }
- blank = newLine[screen_columns-1];
+ blank = newLine[screen_columns - 1];
- if(!can_clear_with(blank))
- {
- /* find the last differing character */
- nLastChar = screen_columns - 1;
+ if (!can_clear_with(blank)) {
+ /* find the last differing character */
+ nLastChar = screen_columns - 1;
- while (nLastChar > firstChar
- && newLine[nLastChar] == oldLine[nLastChar])
- nLastChar--;
+ while (nLastChar > firstChar
+ && newLine[nLastChar] == oldLine[nLastChar])
+ nLastChar--;
- if (nLastChar >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(oldLine, newLine, lineno, firstChar, nLastChar);
- memcpy( oldLine + firstChar,
- newLine + firstChar,
- (nLastChar - firstChar + 1) * sizeof(chtype));
- }
- return;
- }
+ if (nLastChar >= firstChar) {
+ GoTo(lineno, firstChar);
+ PutRange(oldLine, newLine, lineno, firstChar, nLastChar);
+ memcpy(oldLine + firstChar,
+ newLine + firstChar,
+ (nLastChar - firstChar + 1) * sizeof(chtype));
+ }
+ return;
+ }
- /* find last non-blank character on old line */
- oLastChar = screen_columns - 1;
- while (oLastChar > firstChar && oldLine[oLastChar] == blank)
- oLastChar--;
-
- /* find last non-blank character on new line */
- nLastChar = screen_columns - 1;
- while (nLastChar > firstChar && newLine[nLastChar] == blank)
- nLastChar--;
-
- if((nLastChar == firstChar)
- && (SP->_el_cost < (oLastChar - nLastChar))) {
- GoTo(lineno, firstChar);
- if(newLine[firstChar] != blank )
- PutChar(newLine[firstChar]);
- ClrToEOL(blank);
- } else if( (nLastChar != oLastChar)
- && (newLine[nLastChar] != oldLine[oLastChar]
- || !(_nc_idcok && has_ic())) ) {
- GoTo(lineno, firstChar);
- if ((oLastChar - nLastChar) > SP->_el_cost) {
- if(PutRange(oldLine, newLine, lineno, firstChar, nLastChar))
- GoTo(lineno, nLastChar+1);
- ClrToEOL(blank);
- } else {
- n = max( nLastChar , oLastChar );
- PutRange(oldLine, newLine, lineno, firstChar, n);
- }
+ /* find last non-blank character on old line */
+ oLastChar = screen_columns - 1;
+ while (oLastChar > firstChar && oldLine[oLastChar] == blank)
+ oLastChar--;
+
+ /* find last non-blank character on new line */
+ nLastChar = screen_columns - 1;
+ while (nLastChar > firstChar && newLine[nLastChar] == blank)
+ nLastChar--;
+
+ if ((nLastChar == firstChar)
+ && (SP->_el_cost < (oLastChar - nLastChar))) {
+ GoTo(lineno, firstChar);
+ if (newLine[firstChar] != blank)
+ PutChar(newLine[firstChar]);
+ ClrToEOL(blank);
+ } else if ((nLastChar != oLastChar)
+ && (newLine[nLastChar] != oldLine[oLastChar]
+ || !(_nc_idcok && has_ic()))) {
+ GoTo(lineno, firstChar);
+ if ((oLastChar - nLastChar) > SP->_el_cost) {
+ if (PutRange(oldLine, newLine, lineno, firstChar, nLastChar))
+ GoTo(lineno, nLastChar + 1);
+ ClrToEOL(blank);
+ } else {
+ n = max(nLastChar, oLastChar);
+ PutRange(oldLine, newLine, lineno, firstChar, n);
+ }
+ } else {
+ int nLastNonblank = nLastChar;
+ int oLastNonblank = oLastChar;
+
+ /* find the last characters that really differ */
+ while (newLine[nLastChar] == oldLine[oLastChar]) {
+ if (nLastChar != 0
+ && oLastChar != 0) {
+ nLastChar--;
+ oLastChar--;
} else {
- int nLastNonblank = nLastChar;
- int oLastNonblank = oLastChar;
-
- /* find the last characters that really differ */
- while (newLine[nLastChar] == oldLine[oLastChar]) {
- if (nLastChar != 0
- && oLastChar != 0) {
- nLastChar--;
- oLastChar--;
- } else {
- break;
- }
- }
+ break;
+ }
+ }
- n = min(oLastChar, nLastChar);
- if (n >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(oldLine, newLine, lineno, firstChar, n);
- }
+ n = min(oLastChar, nLastChar);
+ if (n >= firstChar) {
+ GoTo(lineno, firstChar);
+ PutRange(oldLine, newLine, lineno, firstChar, n);
+ }
- if (oLastChar < nLastChar) {
- int m = max(nLastNonblank, oLastNonblank);
- GoTo(lineno, n+1);
- if (InsCharCost(nLastChar - oLastChar)
- > (m - n)) {
- PutRange(oldLine, newLine, lineno, n+1, m);
- } else {
- InsStr(&newLine[n+1], nLastChar - oLastChar);
- }
- } else if (oLastChar > nLastChar ) {
- GoTo(lineno, n+1);
- if (DelCharCost(oLastChar - nLastChar)
- > SP->_el_cost + nLastNonblank - (n+1)) {
- if(PutRange(oldLine, newLine, lineno,
- n+1, nLastNonblank))
- GoTo(lineno, nLastNonblank+1);
- ClrToEOL(blank);
- } else {
- /*
- * The delete-char sequence will
- * effectively shift in blanks from the
- * right margin of the screen. Ensure
- * that they are the right color by
- * setting the video attributes from
- * the last character on the row.
- */
- UpdateAttrs(blank);
- DelChar(oLastChar - nLastChar);
- }
- }
+ if (oLastChar < nLastChar) {
+ int m = max(nLastNonblank, oLastNonblank);
+ GoTo(lineno, n + 1);
+ if (InsCharCost(nLastChar - oLastChar)
+ > (m - n)) {
+ PutRange(oldLine, newLine, lineno, n + 1, m);
+ } else {
+ InsStr(&newLine[n + 1], nLastChar - oLastChar);
+ }
+ } else if (oLastChar > nLastChar) {
+ GoTo(lineno, n + 1);
+ if (DelCharCost(oLastChar - nLastChar)
+ > SP->_el_cost + nLastNonblank - (n + 1)) {
+ if (PutRange(oldLine, newLine, lineno,
+ n + 1, nLastNonblank))
+ GoTo(lineno, nLastNonblank + 1);
+ ClrToEOL(blank);
+ } else {
+ /*
+ * The delete-char sequence will
+ * effectively shift in blanks from the
+ * right margin of the screen. Ensure
+ * that they are the right color by
+ * setting the video attributes from
+ * the last character on the row.
+ */
+ UpdateAttrs(blank);
+ DelChar(oLastChar - nLastChar);
}
+ }
}
+ }
- /* update the code's internal representation */
- if (screen_columns > firstChar)
- memcpy( oldLine + firstChar,
- newLine + firstChar,
- (screen_columns - firstChar) * sizeof(chtype));
+ /* update the code's internal representation */
+ if (screen_columns > firstChar)
+ memcpy(oldLine + firstChar,
+ newLine + firstChar,
+ (screen_columns - firstChar) * sizeof(chtype));
}
/*
**
*/
-static void ClearScreen(chtype blank)
+static void
+ClearScreen(chtype blank)
{
- int i, j;
- bool fast_clear = (clear_screen || clr_eos || clr_eol);
+ int i, j;
+ bool fast_clear = (clear_screen || clr_eos || clr_eol);
- T(("ClearScreen() called"));
+ T(("ClearScreen() called"));
#ifdef NCURSES_EXT_FUNCS
- if (SP->_coloron
- && !SP->_default_color) {
- _nc_do_color(0, FALSE, _nc_outch);
- if (!back_color_erase) {
- fast_clear = FALSE;
- }
+ if (SP->_coloron
+ && !SP->_default_color) {
+ _nc_do_color(0, FALSE, _nc_outch);
+ if (!back_color_erase) {
+ fast_clear = FALSE;
}
+ }
#endif
- if (fast_clear) {
- if (clear_screen) {
- UpdateAttrs(blank);
- TPUTS_TRACE("clear_screen");
- putp(clear_screen);
- SP->_cursrow = SP->_curscol = 0;
- position_check(SP->_cursrow, SP->_curscol, "ClearScreen");
- } else if (clr_eos) {
- SP->_cursrow = SP->_curscol = -1;
- GoTo(0,0);
-
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_eos");
- putp(clr_eos);
- } else if (clr_eol) {
- SP->_cursrow = SP->_curscol = -1;
-
- for (i = 0; i < screen_lines; i++) {
- GoTo(i, 0);
- UpdateAttrs(blank);
- TPUTS_TRACE("clr_eol");
- putp(clr_eol);
- }
- GoTo(0,0);
- }
- } else {
- for (i = 0; i < screen_lines; i++) {
- GoTo(i, 0);
- UpdateAttrs(blank);
- for (j = 0; j < screen_columns; j++)
- PutChar(blank);
- }
- GoTo(0,0);
- }
+ if (fast_clear) {
+ if (clear_screen) {
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clear_screen");
+ putp(clear_screen);
+ SP->_cursrow = SP->_curscol = 0;
+ position_check(SP->_cursrow, SP->_curscol, "ClearScreen");
+ } else if (clr_eos) {
+ SP->_cursrow = SP->_curscol = -1;
+ GoTo(0, 0);
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_eos");
+ putp(clr_eos);
+ } else if (clr_eol) {
+ SP->_cursrow = SP->_curscol = -1;
+
+ for (i = 0; i < screen_lines; i++) {
+ GoTo(i, 0);
+ UpdateAttrs(blank);
+ TPUTS_TRACE("clr_eol");
+ putp(clr_eol);
+ }
+ GoTo(0, 0);
+ }
+ } else {
for (i = 0; i < screen_lines; i++) {
- for (j = 0; j < screen_columns; j++)
- curscr->_line[i].text[j] = blank;
+ GoTo(i, 0);
+ UpdateAttrs(blank);
+ for (j = 0; j < screen_columns; j++)
+ PutChar(blank);
}
+ GoTo(0, 0);
+ }
- T(("screen cleared"));
+ for (i = 0; i < screen_lines; i++) {
+ for (j = 0; j < screen_columns; j++)
+ curscr->_line[i].text[j] = blank;
+ }
+
+ T(("screen cleared"));
}
/*
**
*/
-static void InsStr(chtype *line, int count)
+static void
+InsStr(chtype * line, int count)
{
- T(("InsStr(%p,%d) called", line, count));
-
- /* Prefer parm_ich as it has the smallest cost - no need to shift
- * the whole line on each character. */
- /* The order must match that of InsCharCost. */
- if (parm_ich) {
- TPUTS_TRACE("parm_ich");
- tputs(tparm(parm_ich, count), count, _nc_outch);
- while (count) {
- PutAttrChar(*line);
- line++;
- count--;
- }
- } else if (enter_insert_mode && exit_insert_mode) {
- TPUTS_TRACE("enter_insert_mode");
- putp(enter_insert_mode);
- while (count) {
- PutAttrChar(*line);
- if (insert_padding)
- {
- TPUTS_TRACE("insert_padding");
- putp(insert_padding);
- }
- line++;
- count--;
- }
- TPUTS_TRACE("exit_insert_mode");
- putp(exit_insert_mode);
- } else {
- while (count) {
- TPUTS_TRACE("insert_character");
- putp(insert_character);
- PutAttrChar(*line);
- if (insert_padding)
- {
- TPUTS_TRACE("insert_padding");
- putp(insert_padding);
- }
- line++;
- count--;
- }
+ T(("InsStr(%p,%d) called", line, count));
+
+ /* Prefer parm_ich as it has the smallest cost - no need to shift
+ * the whole line on each character. */
+ /* The order must match that of InsCharCost. */
+ if (parm_ich) {
+ TPUTS_TRACE("parm_ich");
+ tputs(tparm(parm_ich, count), count, _nc_outch);
+ while (count) {
+ PutAttrChar(*line);
+ line++;
+ count--;
+ }
+ } else if (enter_insert_mode && exit_insert_mode) {
+ TPUTS_TRACE("enter_insert_mode");
+ putp(enter_insert_mode);
+ while (count) {
+ PutAttrChar(*line);
+ if (insert_padding) {
+ TPUTS_TRACE("insert_padding");
+ putp(insert_padding);
+ }
+ line++;
+ count--;
}
- position_check(SP->_cursrow, SP->_curscol, "InsStr");
+ TPUTS_TRACE("exit_insert_mode");
+ putp(exit_insert_mode);
+ } else {
+ while (count) {
+ TPUTS_TRACE("insert_character");
+ putp(insert_character);
+ PutAttrChar(*line);
+ if (insert_padding) {
+ TPUTS_TRACE("insert_padding");
+ putp(insert_padding);
+ }
+ line++;
+ count--;
+ }
+ }
+ position_check(SP->_cursrow, SP->_curscol, "InsStr");
}
/*
**
*/
-static void DelChar(int count)
+static void
+DelChar(int count)
{
- int n;
+ int n;
- T(("DelChar(%d) called, position = (%d,%d)", count, newscr->_cury, newscr->_curx));
+ T(("DelChar(%d) called, position = (%d,%d)", count, newscr->_cury, newscr->_curx));
- if (parm_dch) {
- TPUTS_TRACE("parm_dch");
- tputs(tparm(parm_dch, count), count, _nc_outch);
- } else {
- for (n = 0; n < count; n++) {
- TPUTS_TRACE("delete_character");
- putp(delete_character);
- }
- }
-#ifdef NCURSES_EXT_FUNCS
- if (FILL_BCE()) {
- chtype blank = ClrBlank(stdscr);
- GoTo(SP->_cursrow, screen_columns - count);
- UpdateAttrs(blank);
- for (n = 0; n < count; n++) {
- PutChar(blank);
- }
+ if (parm_dch) {
+ TPUTS_TRACE("parm_dch");
+ tputs(tparm(parm_dch, count), count, _nc_outch);
+ } else {
+ for (n = 0; n < count; n++) {
+ TPUTS_TRACE("delete_character");
+ putp(delete_character);
}
-#endif
+ }
}
/*
** Emit a string without waiting for update.
*/
-void _nc_outstr(const char *str)
+void
+_nc_outstr(const char *str)
{
(void) putp(str);
_nc_flush();
*/
/* Try to scroll up assuming given csr (miny, maxy). Returns ERR on failure */
-static int scroll_csr_forward(int n, int top, int bot, int miny, int maxy, chtype blank)
+static int
+scroll_csr_forward(int n, int top, int bot, int miny, int maxy, chtype blank)
{
int i, j;
- if (n == 1 && scroll_forward && top == miny && bot == maxy)
- {
+ if (n == 1 && scroll_forward && top == miny && bot == maxy) {
GoTo(bot, 0);
UpdateAttrs(blank);
TPUTS_TRACE("scroll_forward");
tputs(scroll_forward, 0, _nc_outch);
- }
- else if (n == 1 && delete_line && bot == maxy)
- {
+ } else if (n == 1 && delete_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("delete_line");
tputs(delete_line, 0, _nc_outch);
- }
- else if (parm_index && top == miny && bot == maxy)
- {
+ } else if (parm_index && top == miny && bot == maxy) {
GoTo(bot, 0);
UpdateAttrs(blank);
TPUTS_TRACE("parm_index");
tputs(tparm(parm_index, n, 0), n, _nc_outch);
- }
- else if (parm_delete_line && bot == maxy)
- {
+ } else if (parm_delete_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("parm_delete_line");
tputs(tparm(parm_delete_line, n, 0), n, _nc_outch);
- }
- else if (scroll_forward && top == miny && bot == maxy)
- {
+ } else if (scroll_forward && top == miny && bot == maxy) {
GoTo(bot, 0);
UpdateAttrs(blank);
- for (i = 0; i < n; i++)
- {
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("scroll_forward");
tputs(scroll_forward, 0, _nc_outch);
}
- }
- else if (delete_line && bot == maxy)
- {
+ } else if (delete_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
- for (i = 0; i < n; i++)
- {
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("delete_line");
tputs(delete_line, 0, _nc_outch);
}
- }
- else
+ } else
return ERR;
#ifdef NCURSES_EXT_FUNCS
/* Try to scroll down assuming given csr (miny, maxy). Returns ERR on failure */
/* n > 0 */
-static int scroll_csr_backward(int n, int top, int bot, int miny, int maxy, chtype blank)
+static int
+scroll_csr_backward(int n, int top, int bot, int miny, int maxy, chtype blank)
{
int i, j;
- if (n == 1 && scroll_reverse && top == miny && bot == maxy)
- {
+ if (n == 1 && scroll_reverse && top == miny && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("scroll_reverse");
tputs(scroll_reverse, 0, _nc_outch);
- }
- else if (n == 1 && insert_line && bot == maxy)
- {
+ } else if (n == 1 && insert_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("insert_line");
tputs(insert_line, 0, _nc_outch);
- }
- else if (parm_rindex && top == miny && bot == maxy)
- {
+ } else if (parm_rindex && top == miny && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("parm_rindex");
tputs(tparm(parm_rindex, n, 0), n, _nc_outch);
- }
- else if (parm_insert_line && bot == maxy)
- {
+ } else if (parm_insert_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
TPUTS_TRACE("parm_insert_line");
tputs(tparm(parm_insert_line, n, 0), n, _nc_outch);
- }
- else if (scroll_reverse && top == miny && bot == maxy)
- {
+ } else if (scroll_reverse && top == miny && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
- for (i = 0; i < n; i++)
- {
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("scroll_reverse");
tputs(scroll_reverse, 0, _nc_outch);
}
- }
- else if (insert_line && bot == maxy)
- {
+ } else if (insert_line && bot == maxy) {
GoTo(top, 0);
UpdateAttrs(blank);
- for (i = 0; i < n; i++)
- {
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("insert_line");
tputs(insert_line, 0, _nc_outch);
}
- }
- else
+ } else
return ERR;
#ifdef NCURSES_EXT_FUNCS
/* scroll by using delete_line at del and insert_line at ins */
/* n > 0 */
-static int scroll_idl(int n, int del, int ins, chtype blank)
+static int
+scroll_idl(int n, int del, int ins, chtype blank)
{
int i;
- if(!((parm_delete_line || delete_line) && (parm_insert_line || insert_line)))
+ if (!((parm_delete_line || delete_line) && (parm_insert_line || insert_line)))
return ERR;
GoTo(del, 0);
UpdateAttrs(blank);
- if (n == 1 && delete_line)
- {
+ if (n == 1 && delete_line) {
TPUTS_TRACE("delete_line");
tputs(delete_line, 0, _nc_outch);
- }
- else if (parm_delete_line)
- {
+ } else if (parm_delete_line) {
TPUTS_TRACE("parm_delete_line");
tputs(tparm(parm_delete_line, n, 0), n, _nc_outch);
- }
- else /* if (delete_line) */
- {
- for (i = 0; i < n; i++)
- {
+ } else { /* if (delete_line) */
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("delete_line");
tputs(delete_line, 0, _nc_outch);
}
GoTo(ins, 0);
UpdateAttrs(blank);
- if (n == 1 && insert_line)
- {
+ if (n == 1 && insert_line) {
TPUTS_TRACE("insert_line");
tputs(insert_line, 0, _nc_outch);
- }
- else if (parm_insert_line)
- {
+ } else if (parm_insert_line) {
TPUTS_TRACE("parm_insert_line");
tputs(tparm(parm_insert_line, n, 0), n, _nc_outch);
- }
- else /* if (insert_line) */
- {
- for (i = 0; i < n; i++)
- {
+ } else { /* if (insert_line) */
+ for (i = 0; i < n; i++) {
TPUTS_TRACE("insert_line");
tputs(insert_line, 0, _nc_outch);
}
return OK;
}
-int _nc_scrolln(int n, int top, int bot, int maxy)
+int
+_nc_scrolln(int n, int top, int bot, int maxy)
/* scroll region from top to bot by n lines */
{
- chtype blank=ClrBlank(stdscr);
+ chtype blank = ClrBlank(stdscr);
int i;
- bool cursor_saved=FALSE;
+ bool cursor_saved = FALSE;
int res;
TR(TRACE_MOVE, ("mvcur_scrolln(%d, %d, %d, %d)", n, top, bot, maxy));
}
#endif
- if (n > 0) /* scroll up (forward) */
- {
+ if (n > 0) { /* scroll up (forward) */
/*
* Explicitly clear if stuff pushed off top of region might
* be saved by the terminal.
*/
if (non_dest_scroll_region || (memory_above && top == 0)) {
- for (i = 0; i < n; i++)
- {
+ for (i = 0; i < n; i++) {
GoTo(i, 0);
ClrToEOL(BLANK);
}
res = scroll_csr_forward(n, top, bot, 0, maxy, blank);
- if (res == ERR && change_scroll_region)
- {
- if ((((n==1 && scroll_forward) || parm_index)
- && (SP->_cursrow == bot || SP->_cursrow == bot-1))
- && save_cursor && restore_cursor)
- {
- cursor_saved=TRUE;
+ if (res == ERR && change_scroll_region) {
+ if ((((n == 1 && scroll_forward) || parm_index)
+ && (SP->_cursrow == bot || SP->_cursrow == bot - 1))
+ && save_cursor && restore_cursor) {
+ cursor_saved = TRUE;
TPUTS_TRACE("save_cursor");
tputs(save_cursor, 0, _nc_outch);
}
TPUTS_TRACE("change_scroll_region");
tputs(tparm(change_scroll_region, top, bot), 0, _nc_outch);
- if (cursor_saved)
- {
+ if (cursor_saved) {
TPUTS_TRACE("restore_cursor");
tputs(restore_cursor, 0, _nc_outch);
- }
- else
- {
+ } else {
SP->_cursrow = SP->_curscol = -1;
}
}
if (res == ERR && _nc_idlok)
- res = scroll_idl(n, top, bot-n+1, blank);
- }
- else /* (n < 0) - scroll down (backward) */
- {
+ res = scroll_idl(n, top, bot - n + 1, blank);
+ } else { /* (n < 0) - scroll down (backward) */
/*
* Do explicit clear to end of region if it's possible that the
* terminal might hold on to stuff we push off the end.
*/
- if (non_dest_scroll_region || (memory_below && bot == maxy))
- {
- if (bot == maxy && clr_eos)
- {
+ if (non_dest_scroll_region || (memory_below && bot == maxy)) {
+ if (bot == maxy && clr_eos) {
GoTo(maxy + n, 0);
ClrToEOS(BLANK);
- }
- else if (clr_eol)
- {
- for (i = 0; i < -n; i++)
- {
+ } else if (clr_eol) {
+ for (i = 0; i < -n; i++) {
GoTo(maxy + n + i, 0);
ClrToEOL(BLANK);
}
res = scroll_csr_backward(-n, top, bot, 0, maxy, blank);
- if (res == ERR && change_scroll_region)
- {
- if (top != 0 && (SP->_cursrow == top || SP->_cursrow == top-1)
- && save_cursor && restore_cursor)
- {
- cursor_saved=TRUE;
+ if (res == ERR && change_scroll_region) {
+ if (top != 0 && (SP->_cursrow == top || SP->_cursrow == top - 1)
+ && save_cursor && restore_cursor) {
+ cursor_saved = TRUE;
TPUTS_TRACE("save_cursor");
tputs(save_cursor, 0, _nc_outch);
}
TPUTS_TRACE("change_scroll_region");
tputs(tparm(change_scroll_region, top, bot), 0, _nc_outch);
- if (cursor_saved)
- {
+ if (cursor_saved) {
TPUTS_TRACE("restore_cursor");
tputs(restore_cursor, 0, _nc_outch);
- }
- else
- {
+ } else {
SP->_cursrow = SP->_curscol = -1;
}
}
if (res == ERR && _nc_idlok)
- res = scroll_idl(-n, bot+n+1, top, blank);
+ res = scroll_idl(-n, bot + n + 1, top, blank);
}
if (res == ERR)
- return(ERR);
+ return (ERR);
_nc_scroll_window(curscr, n, top, bot, blank);
/* shift hash values too - they can be reused */
_nc_scroll_oldhash(n, top, bot);
- return(OK);
+ return (OK);
}
-
-void _nc_screen_resume()
+void
+_nc_screen_resume(void)
{
/* make sure terminal is in a sane known state */
SP->_current_attr = A_NORMAL;
putp(orig_pair);
if (exit_attribute_mode)
putp(exit_attribute_mode);
- else
- {
+ else {
/* turn off attributes */
if (exit_alt_charset_mode)
putp(exit_alt_charset_mode);
putp(auto_right_margin ? enter_am_mode : exit_am_mode);
}
-void _nc_screen_init()
+void
+_nc_screen_init(void)
{
_nc_screen_resume();
}
/* wrap up screen handling */
-void _nc_screen_wrap()
+void
+_nc_screen_wrap(void)
{
UpdateAttrs(A_NORMAL);
#ifdef NCURSES_EXT_FUNCS
if (SP->_coloron
- && !SP->_default_color) {
+ && !SP->_default_color) {
SP->_default_color = TRUE;
_nc_do_color(0, FALSE, _nc_outch);
SP->_default_color = FALSE;
}
#if USE_XMC_SUPPORT
-void _nc_do_xmc_glitch(attr_t previous)
+void
+_nc_do_xmc_glitch(attr_t previous)
{
- attr_t chg = XMC_CHANGES(previous ^ SP->_current_attr);
-
- while (chg != 0) {
- if (chg & 1) {
- SP->_curscol += magic_cookie_glitch;
- if (SP->_curscol >= SP->_columns)
- wrap_cursor();
- T(("bumped to %d,%d after cookie", SP->_cursrow, SP->_curscol));
- }
- chg >>= 1;
+ attr_t chg = XMC_CHANGES(previous ^ SP->_current_attr);
+
+ while (chg != 0) {
+ if (chg & 1) {
+ SP->_curscol += magic_cookie_glitch;
+ if (SP->_curscol >= SP->_columns)
+ wrap_cursor();
+ T(("bumped to %d,%d after cookie", SP->_cursrow, SP->_curscol));
}
+ chg >>= 1;
+ }
}
#endif /* USE_XMC_SUPPORT */
#!/bin/sh
-# $From: MKtermsort.sh,v 1.5 1999/12/04 21:45:35 tom Exp $
+# $OpenBSD: MKtermsort.sh,v 1.4 2000/03/10 01:35:06 millert Exp $
+# $From: MKtermsort.sh,v 1.6 2000/01/25 11:35:36 tom Exp $
#
# MKtermsort.sh -- generate indirection vectors for the various sort methods
#
# The output of this script is C source for nine arrays that list three sort
# orders for each of the three different classes of terminfo capabilities.
#
-# $OpenBSD: MKtermsort.sh,v 1.3 1999/12/06 02:14:33 millert Exp $
+# keep the order independent of locale:
+LANGUAGE=C
+LC_ALL=C
+export LANGUAGE
+export LC_ALL
#
AWK=${1-awk}
DATA=${2-../include/Caps}
-/* $OpenBSD: progs.priv.h,v 1.4 2000/01/02 21:48:13 millert Exp $ */
+/* $OpenBSD: progs.priv.h,v 1.5 2000/03/10 01:35:06 millert Exp $ */
/****************************************************************************
* Copyright (c) 1998-2000 Free Software Foundation, Inc. *
* Author: Thomas E. Dickey <dickey@clark.net> 1997,1998 *
****************************************************************************/
/*
- * $From: progs.priv.h,v 1.20 2000/01/02 00:56:44 tom Exp $
+ * $From: progs.priv.h,v 1.21 2000/03/05 04:32:47 tom Exp $
*
* progs.priv.h
*
# define isascii(c) 1 /* not really ascii anyway */
# endif
#endif
+
+#if !HAVE_STRDUP
+#define strdup _nc_strdup
+extern char *_nc_strdup(const char *);
+#endif /* not HAVE_STRDUP */
/****************************************************************************
- * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
#include <dump_entry.h>
#include <term_entry.h>
-MODULE_ID("$From: tic.c,v 1.57 2000/01/15 21:44:28 tom Exp $")
+MODULE_ID("$From: tic.c,v 1.63 2000/03/05 04:33:15 tom Exp $")
const char *_nc_progname = "tic";
return (code);
}
+static FILE *
+open_tempfile(char *name)
+{
+ FILE *result = 0;
+#if HAVE_MKSTEMP
+ int fd = mkstemp(name);
+ if (fd >= 0)
+ result = fdopen(fd, "w");
+#else
+ if (tmpnam(name) != 0)
+ result = fopen(name, "w");
+#endif
+ return result;
+}
+
int
main(int argc, char *argv[])
{
int outform = F_TERMINFO; /* output format */
int sortmode = S_TERMINFO; /* sort_mode */
- int fd;
int width = 60;
bool formatted = FALSE; /* reformat complex strings? */
int numbers = 0; /* format "%'char'" to/from "%{number}" */
if (access(termcap, F_OK) == 0) {
/* file exists */
source_file = termcap;
- } else if (strcpy(my_tmpname, "/tmp/tic.XXXXXXXX")
- && (fd = mkstemp(my_tmpname)) != -1
- && (tmp_fp = fdopen(fd, "w")) != 0) {
+ } else if ((tmp_fp = open_tempfile(my_tmpname)) != 0) {
+ source_file = my_tmpname;
fprintf(tmp_fp, "%s\n", termcap);
fclose(tmp_fp);
tmp_fp = fopen(source_file, "r");
#undef CUR
#define CUR tp->
+/*
+ * An sgr string may contain several settings other than the one we're
+ * interested in, essentially sgr0 + rmacs + whatever. As long as the
+ * "whatever" is contained in the sgr string, that is close enough for our
+ * sanity check.
+ */
+static bool
+similar_sgr(char *a, char *b)
+{
+ while (*b != 0) {
+ while (*a != *b) {
+ if (*a == 0)
+ return FALSE;
+ a++;
+ }
+ a++;
+ b++;
+ }
+ return TRUE;
+}
+
+static void
+check_sgr(TERMTYPE * tp, char *zero, int num, char *cap, char *name)
+{
+ char *test = tparm(set_attributes,
+ num == 1,
+ num == 2,
+ num == 3,
+ num == 4,
+ num == 5,
+ num == 6,
+ num == 7,
+ num == 8,
+ num == 9);
+ if (test != 0) {
+ if (PRESENT(cap)) {
+ if (!similar_sgr(test, cap)) {
+ _nc_warning("%s differs from sgr(%d): %s", name, num,
+ _nc_visbuf(test));
+ }
+ } else if (strcmp(test, zero)) {
+ _nc_warning("sgr(%d) present, but not %s", num, name);
+ }
+ } else if (PRESENT(cap)) {
+ _nc_warning("sgr(%d) missing, but %s present", num, name);
+ }
+}
+
+#define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name)
+
/* other sanity-checks (things that we don't want in the normal
* logic that reads a terminfo entry)
*/
|| (max_colors > max_pairs))
_nc_warning("inconsistent values for max_colors and max_pairs");
- PAIRED(set_foreground, set_background)
- PAIRED(set_a_foreground, set_a_background)
+ PAIRED(set_foreground, set_background);
+ PAIRED(set_a_foreground, set_a_background);
/*
* These may be mismatched because the terminal description relies on
* restoring the cursor visibility by resetting it.
*/
- ANDMISSING(cursor_invisible, cursor_normal)
- ANDMISSING(cursor_visible, cursor_normal)
+ ANDMISSING(cursor_invisible, cursor_normal);
+ ANDMISSING(cursor_visible, cursor_normal);
+
+ if (PRESENT(cursor_visible) && PRESENT(cursor_normal)
+ && !strcmp(cursor_visible, cursor_normal))
+ _nc_warning("cursor_visible is same as cursor_normal");
/*
* From XSI & O'Reilly, we gather that sc/rc are required if csr is
* given, because the cursor position after the scrolling operation is
* performed is undefined.
*/
- ANDMISSING(change_scroll_region, save_cursor)
- ANDMISSING(change_scroll_region, restore_cursor)
+ ANDMISSING(change_scroll_region, save_cursor);
+ ANDMISSING(change_scroll_region, restore_cursor);
+
+ if (PRESENT(set_attributes)) {
+ char *zero = tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+ zero = strdup(zero);
+ CHECK_SGR(1, enter_standout_mode);
+ CHECK_SGR(2, enter_underline_mode);
+ CHECK_SGR(3, enter_reverse_mode);
+ CHECK_SGR(4, enter_blink_mode);
+ CHECK_SGR(5, enter_dim_mode);
+ CHECK_SGR(6, enter_bold_mode);
+ CHECK_SGR(7, enter_secure_mode);
+ CHECK_SGR(8, enter_protected_mode);
+ CHECK_SGR(9, enter_alt_charset_mode);
+ free(zero);
+ }
/*
* Some standard applications (e.g., vi) and some non-curses
* smir/rmir. Let's be nice and warn about that, too, even though
* ncurses handles it.
*/
- if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
+ if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
&& (PRESENT(insert_character) || PRESENT(parm_ich))) {
_nc_warning("non-curses applications may be confused by ich/ich1 with smir/rmir");
}
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
****************************************************************************/
-
/*
* tset.c - terminal initialization utility
*
#include <sys/ptem.h>
#endif
-#include <curses.h> /* for bool typedef */
+#include <curses.h> /* for bool typedef */
#include <dump_entry.h>
-MODULE_ID("$From: tset.c,v 0.37 1999/03/14 12:30:02 tom Exp $")
+MODULE_ID("$From: tset.c,v 0.40 2000/03/05 04:37:53 tom Exp $")
extern char **environ;
static TTY mode, oldmode;
-static int terasechar = -1; /* new erase character */
-static int intrchar = -1; /* new interrupt character */
-static int isreset; /* invoked as reset */
-static int tkillchar = -1; /* new kill character */
-static int tlines, tcolumns; /* window size */
+static int terasechar = -1; /* new erase character */
+static int intrchar = -1; /* new interrupt character */
+static int isreset; /* invoked as reset */
+static int tkillchar = -1; /* new kill character */
+static int tlines, tcolumns; /* window size */
#define LOWERCASE(c) ((isalpha(c) && isupper(c)) ? tolower(c) : (c))
static int
-CaselessCmp(const char *a, const char *b) /* strcasecmp isn't portable */
-{
- while (*a && *b) {
- int cmp = LOWERCASE(*a) - LOWERCASE(*b);
- if (cmp != 0)
- break;
- a++, b++;
- }
- return LOWERCASE(*a) - LOWERCASE(*b);
+CaselessCmp(const char *a, const char *b)
+{ /* strcasecmp isn't portable */
+ while (*a && *b) {
+ int cmp = LOWERCASE(*a) - LOWERCASE(*b);
+ if (cmp != 0)
+ break;
+ a++, b++;
+ }
+ return LOWERCASE(*a) - LOWERCASE(*b);
}
-#if !HAVE_STRDUP
-#define strdup _nc_strdup
-extern char *_nc_strdup(const char *);
-#endif /* not HAVE_STRDUP */
-
static void
-err(const char *fmt, ...)
+err(const char *fmt,...)
{
- va_list ap;
- va_start(ap, fmt);
- (void)fprintf(stderr, "tset: ");
- (void)vfprintf(stderr, fmt, ap);
- va_end(ap);
- (void)fprintf(stderr, "\n");
- exit(EXIT_FAILURE);
- /* NOTREACHED */
+ va_list ap;
+ va_start(ap, fmt);
+ (void) fprintf(stderr, "tset: ");
+ (void) vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ (void) fprintf(stderr, "\n");
+ exit(EXIT_FAILURE);
+ /* NOTREACHED */
}
static void
failed(const char *msg)
{
- (void)fputs("tset: ", stderr);
- perror(msg);
- exit(EXIT_FAILURE);
- /* NOTREACHED */
+ (void)fputs("tset: ", stderr);
+ perror(msg);
+ exit(EXIT_FAILURE);
+ /* NOTREACHED */
}
static void
cat(char *file)
{
- register int fd, nr, nw;
- char buf[BUFSIZ];
-
- if ((fd = open(file, O_RDONLY, 0)) < 0)
- failed(file);
-
- while ((nr = read(fd, buf, sizeof(buf))) > 0)
- if ((nw = write(STDERR_FILENO, buf, (size_t)nr)) == -1)
- failed("write to stderr");
- if (nr != 0)
- failed(file);
- (void)close(fd);
+ register int fd, nr, nw;
+ char buf[BUFSIZ];
+
+ if ((fd = open(file, O_RDONLY, 0)) < 0)
+ failed(file);
+
+ while ((nr = read(fd, buf, sizeof(buf))) > 0)
+ if ((nw = write(STDERR_FILENO, buf, (size_t) nr)) == -1)
+ failed("write to stderr");
+ if (nr != 0)
+ failed(file);
+ (void) close(fd);
}
static int
outc(int c)
{
- return putc(c, stderr);
+ return putc(c, stderr);
}
/* Prompt the user for a terminal type. */
static const char *
askuser(const char *dflt)
{
- static char answer[256];
- char *p;
+ static char answer[256];
+ char *p;
- /* We can get recalled; if so, don't continue uselessly. */
- if (feof(stdin) || ferror(stdin)) {
- (void)fprintf(stderr, "\n");
+ /* We can get recalled; if so, don't continue uselessly. */
+ if (feof(stdin) || ferror(stdin)) {
+ (void) fprintf(stderr, "\n");
+ exit(EXIT_FAILURE);
+ }
+ for (;;) {
+ if (dflt)
+ (void) fprintf(stderr, "Terminal type? [%s] ", dflt);
+ else
+ (void) fprintf(stderr, "Terminal type? ");
+ (void) fflush(stderr);
+
+ if (fgets(answer, sizeof(answer), stdin) == 0) {
+ if (dflt == 0) {
+ (void) fprintf(stderr, "\n");
exit(EXIT_FAILURE);
+ }
+ return (dflt);
}
- for (;;) {
- if (dflt)
- (void)fprintf(stderr, "Terminal type? [%s] ", dflt);
- else
- (void)fprintf(stderr, "Terminal type? ");
- (void)fflush(stderr);
-
- if (fgets(answer, sizeof(answer), stdin) == 0) {
- if (dflt == 0) {
- (void)fprintf(stderr, "\n");
- exit(EXIT_FAILURE);
- }
- return (dflt);
- }
- if ((p = strchr(answer, '\n')) != 0)
- *p = '\0';
- if (answer[0])
- return (answer);
- if (dflt != 0)
- return (dflt);
- }
+ if ((p = strchr(answer, '\n')) != 0)
+ *p = '\0';
+ if (answer[0])
+ return (answer);
+ if (dflt != 0)
+ return (dflt);
+ }
}
/**************************************************************************
#define LE (LT | EQ)
typedef struct map {
- struct map *next; /* Linked list of maps. */
- const char *porttype; /* Port type, or "" for any. */
- const char *type; /* Terminal type to select. */
- int conditional; /* Baud rate conditionals bitmask. */
- speed_t speed; /* Baud rate to compare against. */
+ struct map *next; /* Linked list of maps. */
+ const char *porttype; /* Port type, or "" for any. */
+ const char *type; /* Terminal type to select. */
+ int conditional; /* Baud rate conditionals bitmask. */
+ speed_t speed; /* Baud rate to compare against. */
} MAP;
static MAP *cur, *maplist;
typedef struct speeds {
- const char *string;
- int speed;
+ const char *string;
+ int speed;
} SPEEDS;
-static const SPEEDS speeds[] = {
- { "0", B0 },
- { "50", B50 },
- { "75", B75 },
- { "110", B110 },
- { "134", B134 },
- { "134.5", B134 },
- { "150", B150 },
- { "200", B200 },
- { "300", B300 },
- { "600", B600 },
- { "1200", B1200 },
- { "1800", B1800 },
- { "2400", B2400 },
- { "4800", B4800 },
- { "9600", B9600 },
- { "19200", B19200 },
- { "38400", B38400 },
- { "19200", B19200 },
- { "38400", B38400 },
+static const SPEEDS speeds[] =
+{
+ {"0", B0},
+ {"50", B50},
+ {"75", B75},
+ {"110", B110},
+ {"134", B134},
+ {"134.5", B134},
+ {"150", B150},
+ {"200", B200},
+ {"300", B300},
+ {"600", B600},
+ {"1200", B1200},
+ {"1800", B1800},
+ {"2400", B2400},
+ {"4800", B4800},
+ {"9600", B9600},
+ {"19200", B19200},
+ {"38400", B38400},
+ {"19200", B19200},
+ {"38400", B38400},
#ifdef B19200
- { "19200", B19200 },
+ {"19200", B19200},
#else
#ifdef EXTA
- { "19200", EXTA },
+ {"19200", EXTA},
#endif
#endif
#ifdef B38400
- { "38400", B38400 },
+ {"38400", B38400},
#else
#ifdef EXTB
- { "38400", EXTB },
+ {"38400", EXTB},
#endif
#endif
#ifdef B57600
- { "57600", B57600 },
+ {"57600", B57600},
#endif
#ifdef B115200
- { "115200", B115200 },
+ {"115200", B115200},
#endif
#ifdef B230400
- { "230400", B230400 },
+ {"230400", B230400},
#endif
#ifdef B460800
- { "460800", B460800 },
+ {"460800", B460800},
#endif
- { (char *)0, 0 }
+ {(char *) 0, 0}
};
static int
tbaudrate(char *rate)
{
- const SPEEDS *sp;
- int found = FALSE;
+ const SPEEDS *sp;
+ int found = FALSE;
- /* The baudrate number can be preceded by a 'B', which is ignored. */
- if (*rate == 'B')
- ++rate;
+ /* The baudrate number can be preceded by a 'B', which is ignored. */
+ if (*rate == 'B')
+ ++rate;
- for (sp = speeds; sp->string; ++sp) {
- if (!CaselessCmp(rate, sp->string)) {
- found = TRUE;
- break;
- }
+ for (sp = speeds; sp->string; ++sp) {
+ if (!CaselessCmp(rate, sp->string)) {
+ found = TRUE;
+ break;
}
- if (!found)
- err("unknown baud rate %s", rate);
- return (sp->speed);
+ }
+ if (!found)
+ err("unknown baud rate %s", rate);
+ return (sp->speed);
}
/*
static void
add_mapping(const char *port, char *arg)
{
- MAP *mapp;
- char *copy, *p;
- const char *termp;
- char *base = 0;
-
- copy = strdup(arg);
- mapp = malloc(sizeof(MAP));
- if (copy == 0 || mapp == 0)
- failed("malloc");
- mapp->next = 0;
- if (maplist == 0)
- cur = maplist = mapp;
- else {
- cur->next = mapp;
- cur = mapp;
- }
-
- mapp->porttype = arg;
- mapp->conditional = 0;
-
- arg = strpbrk(arg, "><@=!:");
-
- if (arg == 0) { /* [?]term */
- mapp->type = mapp->porttype;
- mapp->porttype = 0;
- goto done;
- }
-
- if (arg == mapp->porttype) /* [><@=! baud]:term */
- termp = mapp->porttype = 0;
- else
- termp = base = arg;
-
- for (;; ++arg) /* Optional conditionals. */
- switch(*arg) {
- case '<':
- if (mapp->conditional & GT)
- goto badmopt;
- mapp->conditional |= LT;
- break;
- case '>':
- if (mapp->conditional & LT)
- goto badmopt;
- mapp->conditional |= GT;
- break;
- case '@':
- case '=': /* Not documented. */
- mapp->conditional |= EQ;
- break;
- case '!':
- mapp->conditional |= NOT;
- break;
- default:
- goto next;
- }
-
-next: if (*arg == ':') {
- if (mapp->conditional)
- goto badmopt;
- ++arg;
- } else { /* Optional baudrate. */
- arg = strchr(p = arg, ':');
- if (arg == 0)
- goto badmopt;
- *arg++ = '\0';
- mapp->speed = tbaudrate(p);
- }
-
- if (arg == (char *)0) /* Non-optional type. */
+ MAP *mapp;
+ char *copy, *p;
+ const char *termp;
+ char *base = 0;
+
+ copy = strdup(arg);
+ mapp = malloc(sizeof(MAP));
+ if (copy == 0 || mapp == 0)
+ failed("malloc");
+ mapp->next = 0;
+ if (maplist == 0)
+ cur = maplist = mapp;
+ else {
+ cur->next = mapp;
+ cur = mapp;
+ }
+
+ mapp->porttype = arg;
+ mapp->conditional = 0;
+
+ arg = strpbrk(arg, "><@=!:");
+
+ if (arg == 0) { /* [?]term */
+ mapp->type = mapp->porttype;
+ mapp->porttype = 0;
+ goto done;
+ }
+
+ if (arg == mapp->porttype) /* [><@=! baud]:term */
+ termp = mapp->porttype = 0;
+ else
+ termp = base = arg;
+
+ for (;; ++arg) /* Optional conditionals. */
+ switch (*arg) {
+ case '<':
+ if (mapp->conditional & GT)
goto badmopt;
-
- mapp->type = arg;
-
- /* Terminate porttype, if specified. */
- if (termp != 0)
- *base = '\0';
-
- /* If a NOT conditional, reverse the test. */
- if (mapp->conditional & NOT)
- mapp->conditional = ~mapp->conditional & (EQ | GT | LT);
-
- /* If user specified a port with an option flag, set it. */
-done: if (port) {
- if (mapp->porttype)
-badmopt: err("illegal -m option format: %s", copy);
- mapp->porttype = port;
+ mapp->conditional |= LT;
+ break;
+ case '>':
+ if (mapp->conditional & LT)
+ goto badmopt;
+ mapp->conditional |= GT;
+ break;
+ case '@':
+ case '=': /* Not documented. */
+ mapp->conditional |= EQ;
+ break;
+ case '!':
+ mapp->conditional |= NOT;
+ break;
+ default:
+ goto next;
}
+ next:if (*arg == ':') {
+ if (mapp->conditional)
+ goto badmopt;
+ ++arg;
+ } else { /* Optional baudrate. */
+ arg = strchr(p = arg, ':');
+ if (arg == 0)
+ goto badmopt;
+ *arg++ = '\0';
+ mapp->speed = tbaudrate(p);
+ }
+
+ if (arg == (char *) 0) /* Non-optional type. */
+ goto badmopt;
+
+ mapp->type = arg;
+
+ /* Terminate porttype, if specified. */
+ if (termp != 0)
+ *base = '\0';
+
+ /* If a NOT conditional, reverse the test. */
+ if (mapp->conditional & NOT)
+ mapp->conditional = ~mapp->conditional & (EQ | GT | LT);
+
+ /* If user specified a port with an option flag, set it. */
+ done:if (port) {
+ if (mapp->porttype)
+ badmopt:err("illegal -m option format: %s", copy);
+ mapp->porttype = port;
+ }
#ifdef MAPDEBUG
- (void)printf("port: %s\n", mapp->porttype ? mapp->porttype : "ANY");
- (void)printf("type: %s\n", mapp->type);
- (void)printf("conditional: ");
- p = "";
- if (mapp->conditional & GT) {
- (void)printf("GT");
- p = "/";
- }
- if (mapp->conditional & EQ) {
- (void)printf("%sEQ", p);
- p = "/";
- }
- if (mapp->conditional & LT)
- (void)printf("%sLT", p);
- (void)printf("\nspeed: %d\n", mapp->speed);
+ (void) printf("port: %s\n", mapp->porttype ? mapp->porttype : "ANY");
+ (void) printf("type: %s\n", mapp->type);
+ (void) printf("conditional: ");
+ p = "";
+ if (mapp->conditional & GT) {
+ (void) printf("GT");
+ p = "/";
+ }
+ if (mapp->conditional & EQ) {
+ (void) printf("%sEQ", p);
+ p = "/";
+ }
+ if (mapp->conditional & LT)
+ (void) printf("%sLT", p);
+ (void) printf("\nspeed: %d\n", mapp->speed);
#endif
}
static const char *
mapped(const char *type)
{
- MAP *mapp;
- int match;
-
- for (mapp = maplist; mapp; mapp = mapp->next)
- if (mapp->porttype == 0 || !strcmp(mapp->porttype, type)) {
- switch (mapp->conditional) {
- case 0: /* No test specified. */
- match = TRUE;
- break;
- case EQ:
- match = (ospeed == mapp->speed);
- break;
- case GE:
- match = (ospeed >= mapp->speed);
- break;
- case GT:
- match = (ospeed > mapp->speed);
- break;
- case LE:
- match = (ospeed <= mapp->speed);
- break;
- case LT:
- match = (ospeed < mapp->speed);
- break;
- default:
- match = FALSE;
- }
- if (match)
- return (mapp->type);
- }
- /* No match found; return given type. */
- return (type);
+ MAP *mapp;
+ int match;
+
+ for (mapp = maplist; mapp; mapp = mapp->next)
+ if (mapp->porttype == 0 || !strcmp(mapp->porttype, type)) {
+ switch (mapp->conditional) {
+ case 0: /* No test specified. */
+ match = TRUE;
+ break;
+ case EQ:
+ match = (ospeed == mapp->speed);
+ break;
+ case GE:
+ match = (ospeed >= mapp->speed);
+ break;
+ case GT:
+ match = (ospeed > mapp->speed);
+ break;
+ case LE:
+ match = (ospeed <= mapp->speed);
+ break;
+ case LT:
+ match = (ospeed < mapp->speed);
+ break;
+ default:
+ match = FALSE;
+ }
+ if (match)
+ return (mapp->type);
+ }
+ /* No match found; return given type. */
+ return (type);
}
/**************************************************************************
static const char *
get_termcap_entry(char *userarg)
{
- int rval, errret;
- char *p;
- const char *ttype;
+ int rval, errret;
+ char *p;
+ const char *ttype;
#if HAVE_GETTTYNAM
- struct ttyent *t;
+ struct ttyent *t;
#else
- FILE *fp;
+ FILE *fp;
#endif
- char *ttypath;
+ char *ttypath;
- if (userarg) {
- ttype = userarg;
- goto found;
- }
+ if (userarg) {
+ ttype = userarg;
+ goto found;
+ }
- /* Try the environment. */
- if ((ttype = getenv("TERM")) != 0)
- goto map;
+ /* Try the environment. */
+ if ((ttype = getenv("TERM")) != 0)
+ goto map;
- if ((ttypath = ttyname(STDERR_FILENO)) != 0) {
- if ((p = strrchr(ttypath, '/')) != 0)
- ++p;
- else
- p = ttypath;
+ if ((ttypath = ttyname(STDERR_FILENO)) != 0) {
+ if ((p = strrchr(ttypath, '/')) != 0)
+ ++p;
+ else
+ p = ttypath;
#if HAVE_GETTTYNAM
- /*
- * We have the 4.3BSD library call getttynam(3); that means
- * there's an /etc/ttys to look up device-to-type mappings in.
- * Try ttyname(3); check for dialup or other mapping.
- */
- if ((t = getttynam(p))) {
- ttype = t->ty_type;
- goto map;
- }
+ /*
+ * We have the 4.3BSD library call getttynam(3); that means
+ * there's an /etc/ttys to look up device-to-type mappings in.
+ * Try ttyname(3); check for dialup or other mapping.
+ */
+ if ((t = getttynam(p))) {
+ ttype = t->ty_type;
+ goto map;
+ }
#else
- if ((fp = fopen("/etc/ttytype", "r")) != 0
- || (fp = fopen("/etc/ttys", "r")) != 0) {
- char buffer[BUFSIZ];
- char *s, *t, *d;
-
- while (fgets(buffer, sizeof(buffer)-1, fp) != 0) {
- for (s = buffer, t = d = 0; *s; s++) {
- if (isspace(*s))
- *s = '\0';
- else if (t == 0)
- t = s;
- else if (d == 0 && s != buffer && s[-1] == '\0')
- d = s;
- }
- if (t != 0 && d != 0 && !strcmp(d,p)) {
- ttype = strdup(t);
- fclose(fp);
- goto map;
- }
- }
- fclose(fp);
+ if ((fp = fopen("/etc/ttytype", "r")) != 0
+ || (fp = fopen("/etc/ttys", "r")) != 0) {
+ char buffer[BUFSIZ];
+ char *s, *t, *d;
+
+ while (fgets(buffer, sizeof(buffer) - 1, fp) != 0) {
+ for (s = buffer, t = d = 0; *s; s++) {
+ if (isspace(*s))
+ *s = '\0';
+ else if (t == 0)
+ t = s;
+ else if (d == 0 && s != buffer && s[-1] == '\0')
+ d = s;
}
-#endif /* HAVE_GETTTYNAM */
+ if (t != 0 && d != 0 && !strcmp(d, p)) {
+ ttype = strdup(t);
+ fclose(fp);
+ goto map;
+ }
+ }
+ fclose(fp);
}
+#endif /* HAVE_GETTTYNAM */
+ }
- /* If still undefined, use "unknown". */
- ttype = "unknown";
+ /* If still undefined, use "unknown". */
+ ttype = "unknown";
-map: ttype = mapped(ttype);
+ map:ttype = mapped(ttype);
- /*
- * If not a path, remove TERMCAP from the environment so we get a
- * real entry from /etc/termcap. This prevents us from being fooled
- * by out of date stuff in the environment.
+ /*
+ * If not a path, remove TERMCAP from the environment so we get a
+ * real entry from /etc/termcap. This prevents us from being fooled
+ * by out of date stuff in the environment.
+ */
+ found:if ((p = getenv("TERMCAP")) != 0 && *p != '/') {
+ /* 'unsetenv("TERMCAP")' is not portable.
+ * The 'environ' array is better.
*/
-found: if ((p = getenv("TERMCAP")) != 0 && *p != '/') {
- /* 'unsetenv("TERMCAP")' is not portable.
- * The 'environ' array is better.
- */
- int n;
- for (n = 0; environ[n] != 0; n++) {
- if (!strncmp("TERMCAP=", environ[n], 8)) {
- while ((environ[n] = environ[n+1]) != 0) {
- n++;
- }
- break;
- }
+ int n;
+ for (n = 0; environ[n] != 0; n++) {
+ if (!strncmp("TERMCAP=", environ[n], 8)) {
+ while ((environ[n] = environ[n + 1]) != 0) {
+ n++;
}
+ break;
+ }
}
-
- /*
- * ttype now contains a pointer to the type of the terminal.
- * If the first character is '?', ask the user.
- */
- if (ttype[0] == '?') {
- if (ttype[1] != '\0')
- ttype = askuser(ttype + 1);
- else
- ttype = askuser(0);
- }
- /* Find the terminfo entry. If it doesn't exist, ask the user. */
- while ((rval = setupterm((NCURSES_CONST char *)ttype, STDOUT_FILENO, &errret)) != OK) {
- if (errret == 0) {
- (void)fprintf(stderr, "tset: unknown terminal type %s\n",
- ttype);
- ttype = 0;
- }
- else {
- (void)fprintf(stderr, "tset: can't initialize terminal type %s (error %d)\n", ttype, errret);
- ttype = 0;
- }
- ttype = askuser(ttype);
+ }
+
+ /*
+ * ttype now contains a pointer to the type of the terminal.
+ * If the first character is '?', ask the user.
+ */
+ if (ttype[0] == '?') {
+ if (ttype[1] != '\0')
+ ttype = askuser(ttype + 1);
+ else
+ ttype = askuser(0);
+ }
+ /* Find the terminfo entry. If it doesn't exist, ask the user. */
+ while ((rval = setupterm((NCURSES_CONST char *) ttype, STDOUT_FILENO,
+ &errret)) != OK) {
+ if (errret == 0) {
+ (void) fprintf(stderr, "tset: unknown terminal type %s\n",
+ ttype);
+ ttype = 0;
+ } else {
+ (void) fprintf(stderr,
+ "tset: can't initialize terminal type %s (error %d)\n",
+ ttype, errret);
+ ttype = 0;
}
+ ttype = askuser(ttype);
+ }
#if BROKEN_LINKER
- tgetflag("am"); /* force lib_termcap.o to be linked for 'ospeed' */
+ tgetflag("am"); /* force lib_termcap.o to be linked for 'ospeed' */
#endif
- return (ttype);
+ return (ttype);
}
/**************************************************************************
#define CHK(val, dft) ((int)val <= 0 ? dft : val)
-static bool set_tabs (void);
+static bool set_tabs(void);
/*
* Reset the terminal mode bits to a sensible state. Very useful after
reset_mode(void)
{
#ifdef TERMIOS
- tcgetattr(STDERR_FILENO, &mode);
+ tcgetattr(STDERR_FILENO, &mode);
#else
- stty(STDERR_FILENO,&mode);
+ stty(STDERR_FILENO, &mode);
#endif
#ifdef TERMIOS
#if defined(VDISCARD) && defined(CDISCARD)
- mode.c_cc[VDISCARD] = CHK(mode.c_cc[VDISCARD], CDISCARD);
+ mode.c_cc[VDISCARD] = CHK(mode.c_cc[VDISCARD], CDISCARD);
#endif
- mode.c_cc[VEOF] = CHK(mode.c_cc[VEOF], CEOF);
- mode.c_cc[VERASE] = CHK(mode.c_cc[VERASE], CERASE);
+ mode.c_cc[VEOF] = CHK(mode.c_cc[VEOF], CEOF);
+ mode.c_cc[VERASE] = CHK(mode.c_cc[VERASE], CERASE);
#if defined(VFLUSH) && defined(CFLUSH)
- mode.c_cc[VFLUSH] = CHK(mode.c_cc[VFLUSH], CFLUSH);
+ mode.c_cc[VFLUSH] = CHK(mode.c_cc[VFLUSH], CFLUSH);
#endif
- mode.c_cc[VINTR] = CHK(mode.c_cc[VINTR], CINTR);
- mode.c_cc[VKILL] = CHK(mode.c_cc[VKILL], CKILL);
+ mode.c_cc[VINTR] = CHK(mode.c_cc[VINTR], CINTR);
+ mode.c_cc[VKILL] = CHK(mode.c_cc[VKILL], CKILL);
#if defined(VLNEXT) && defined(CLNEXT)
- mode.c_cc[VLNEXT] = CHK(mode.c_cc[VLNEXT], CLNEXT);
+ mode.c_cc[VLNEXT] = CHK(mode.c_cc[VLNEXT], CLNEXT);
#endif
- mode.c_cc[VQUIT] = CHK(mode.c_cc[VQUIT], CQUIT);
+ mode.c_cc[VQUIT] = CHK(mode.c_cc[VQUIT], CQUIT);
#if defined(VREPRINT) && defined(CRPRNT)
- mode.c_cc[VREPRINT] = CHK(mode.c_cc[VREPRINT], CRPRNT);
+ mode.c_cc[VREPRINT] = CHK(mode.c_cc[VREPRINT], CRPRNT);
#endif
#if defined(VSTART) && defined(CSTART)
- mode.c_cc[VSTART] = CHK(mode.c_cc[VSTART], CSTART);
+ mode.c_cc[VSTART] = CHK(mode.c_cc[VSTART], CSTART);
#endif
#if defined(VSTOP) && defined(CSTOP)
- mode.c_cc[VSTOP] = CHK(mode.c_cc[VSTOP], CSTOP);
+ mode.c_cc[VSTOP] = CHK(mode.c_cc[VSTOP], CSTOP);
#endif
#if defined(VSUSP) && defined(CSUSP)
- mode.c_cc[VSUSP] = CHK(mode.c_cc[VSUSP], CSUSP);
+ mode.c_cc[VSUSP] = CHK(mode.c_cc[VSUSP], CSUSP);
#endif
#if defined(VWERASE) && defined(CWERASE)
- mode.c_cc[VWERASE] = CHK(mode.c_cc[VWERASE], CWERASE);
+ mode.c_cc[VWERASE] = CHK(mode.c_cc[VWERASE], CWERASE);
#endif
- mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | ISTRIP | INLCR | IGNCR
+ mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | ISTRIP | INLCR | IGNCR
#ifdef IUCLC
- | IUCLC
+ | IUCLC
#endif
#ifdef IXANY
- | IXANY
+ | IXANY
#endif
- | IXOFF);
+ | IXOFF);
- mode.c_iflag |= (BRKINT | IGNPAR | ICRNL | IXON
+ mode.c_iflag |= (BRKINT | IGNPAR | ICRNL | IXON
#ifdef IMAXBEL
- | IMAXBEL
+ | IMAXBEL
#endif
- );
+ );
- mode.c_oflag &= ~(0
+ mode.c_oflag &= ~(0
#ifdef OLCUC
- | OLCUC
+ | OLCUC
#endif
#ifdef OCRNL
- | OCRNL
+ | OCRNL
#endif
#ifdef ONOCR
- | ONOCR
+ | ONOCR
#endif
#ifdef ONLRET
- | ONLRET
+ | ONLRET
#endif
#ifdef OFILL
- | OFILL
+ | OFILL
#endif
#ifdef OFDEL
- | OFDEL
+ | OFDEL
#endif
#ifdef NLDLY
- | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY
+ | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY
#endif
- );
+ );
- mode.c_oflag |= (OPOST
+ mode.c_oflag |= (OPOST
#ifdef ONLCR
- | ONLCR
+ | ONLCR
#endif
- );
+ );
- mode.c_cflag &= ~(CSIZE | CSTOPB | PARENB | PARODD | CLOCAL);
- mode.c_cflag |= (CS8 | CREAD);
- mode.c_lflag &= ~(ECHONL | NOFLSH
+ mode.c_cflag &= ~(CSIZE | CSTOPB | PARENB | PARODD | CLOCAL);
+ mode.c_cflag |= (CS8 | CREAD);
+ mode.c_lflag &= ~(ECHONL | NOFLSH
#ifdef TOSTOP
- | TOSTOP
+ | TOSTOP
#endif
#ifdef ECHOPTR
- | ECHOPRT
+ | ECHOPRT
#endif
#ifdef XCASE
- | XCASE
+ | XCASE
#endif
- );
+ );
- mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOE | ECHOK
+ mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOE | ECHOK
#ifdef ECHOCTL
- | ECHOCTL
+ | ECHOCTL
#endif
#ifdef ECHOKE
- | ECHOKE
+ | ECHOKE
#endif
- );
+ );
#endif
#ifdef TERMIOS
- tcsetattr(STDERR_FILENO, TCSADRAIN, &mode);
+ tcsetattr(STDERR_FILENO, TCSADRAIN, &mode);
#else
- stty(STDERR_FILENO, &mode);
+ stty(STDERR_FILENO, &mode);
#endif
}
static int
default_erase(void)
{
- int result;
+ int result;
- if (over_strike
- && key_backspace != 0
- && strlen(key_backspace) == 1)
- result = key_backspace[0];
- else
- result = CERASE;
+ if (over_strike
+ && key_backspace != 0
+ && strlen(key_backspace) == 1)
+ result = key_backspace[0];
+ else
+ result = CERASE;
- return result;
+ return result;
}
/*
set_control_chars(void)
{
#ifdef TERMIOS
- if (mode.c_cc[VERASE] == 0 || terasechar >= 0)
- mode.c_cc[VERASE] = terasechar >= 0 ? terasechar : default_erase();
+ if (mode.c_cc[VERASE] == 0 || terasechar >= 0)
+ mode.c_cc[VERASE] = terasechar >= 0 ? terasechar : default_erase();
- if (mode.c_cc[VINTR] == 0 || intrchar >= 0)
- mode.c_cc[VINTR] = intrchar >= 0 ? intrchar : CINTR;
+ if (mode.c_cc[VINTR] == 0 || intrchar >= 0)
+ mode.c_cc[VINTR] = intrchar >= 0 ? intrchar : CINTR;
- if (mode.c_cc[VKILL] == 0 || tkillchar >= 0)
- mode.c_cc[VKILL] = tkillchar >= 0 ? tkillchar : CKILL;
+ if (mode.c_cc[VKILL] == 0 || tkillchar >= 0)
+ mode.c_cc[VKILL] = tkillchar >= 0 ? tkillchar : CKILL;
#endif
}
set_conversions(void)
{
#ifdef __OBSOLETE__
- /*
- * Conversion logic for some *really* ancient terminal glitches,
- * not supported in terminfo. Left here for succeeding generations
- * to marvel at.
- */
- if (tgetflag("UC")) {
+ /*
+ * Conversion logic for some *really* ancient terminal glitches,
+ * not supported in terminfo. Left here for succeeding generations
+ * to marvel at.
+ */
+ if (tgetflag("UC")) {
#ifdef IUCLC
- mode.c_iflag |= IUCLC;
- mode.c_oflag |= OLCUC;
+ mode.c_iflag |= IUCLC;
+ mode.c_oflag |= OLCUC;
#endif
- } else if (tgetflag("LC")) {
+ } else if (tgetflag("LC")) {
#ifdef IUCLC
- mode.c_iflag &= ~IUCLC;
- mode.c_oflag &= ~OLCUC;
+ mode.c_iflag &= ~IUCLC;
+ mode.c_oflag &= ~OLCUC;
#endif
- }
- mode.c_iflag &= ~(PARMRK | INPCK);
- mode.c_lflag |= ICANON;
- if (tgetflag("EP")) {
- mode.c_cflag |= PARENB;
- mode.c_cflag &= ~PARODD;
- }
- if (tgetflag("OP")) {
- mode.c_cflag |= PARENB;
- mode.c_cflag |= PARODD;
- }
+ }
+ mode.c_iflag &= ~(PARMRK | INPCK);
+ mode.c_lflag |= ICANON;
+ if (tgetflag("EP")) {
+ mode.c_cflag |= PARENB;
+ mode.c_cflag &= ~PARODD;
+ }
+ if (tgetflag("OP")) {
+ mode.c_cflag |= PARENB;
+ mode.c_cflag |= PARODD;
+ }
#endif /* __OBSOLETE__ */
#ifdef TERMIOS
#ifdef ONLCR
- mode.c_oflag |= ONLCR;
+ mode.c_oflag |= ONLCR;
#endif
- mode.c_iflag |= ICRNL;
- mode.c_lflag |= ECHO;
+ mode.c_iflag |= ICRNL;
+ mode.c_lflag |= ECHO;
#ifdef OXTABS
- mode.c_oflag |= OXTABS;
+ mode.c_oflag |= OXTABS;
#endif /* OXTABS */
- /* test used to be tgetflag("NL") */
- if (newline != (char *)0 && newline[0] == '\n' && !newline[1]) {
- /* Newline, not linefeed. */
+ /* test used to be tgetflag("NL") */
+ if (newline != (char *) 0 && newline[0] == '\n' && !newline[1]) {
+ /* Newline, not linefeed. */
#ifdef ONLCR
- mode.c_oflag &= ~ONLCR;
+ mode.c_oflag &= ~ONLCR;
#endif
- mode.c_iflag &= ~ICRNL;
- }
+ mode.c_iflag &= ~ICRNL;
+ }
#ifdef __OBSOLETE__
- if (tgetflag("HD")) /* Half duplex. */
- mode.c_lflag &= ~ECHO;
+ if (tgetflag("HD")) /* Half duplex. */
+ mode.c_lflag &= ~ECHO;
#endif /* __OBSOLETE__ */
#ifdef OXTABS
- /* test used to be tgetflag("pt") */
- if (has_hardware_tabs) /* Print tabs. */
- mode.c_oflag &= ~OXTABS;
+ /* test used to be tgetflag("pt") */
+ if (has_hardware_tabs) /* Print tabs. */
+ mode.c_oflag &= ~OXTABS;
#endif /* OXTABS */
- mode.c_lflag |= (ECHOE | ECHOK);
+ mode.c_lflag |= (ECHOE | ECHOK);
#endif
}
static void
set_init(void)
{
- char *p;
- bool settle;
+ char *p;
+ bool settle;
#ifdef __OBSOLETE__
- if (pad_char != (char *)0) /* Get/set pad character. */
- PC = pad_char[0];
+ if (pad_char != (char *) 0) /* Get/set pad character. */
+ PC = pad_char[0];
#endif /* OBSOLETE */
#ifdef TAB3
- if (oldmode.c_oflag & (TAB3 | ONLCR | OCRNL | ONLRET)) {
- oldmode.c_oflag &= (TAB3 | ONLCR | OCRNL | ONLRET);
- tcsetattr(STDERR_FILENO, TCSADRAIN, &oldmode);
- }
+ if (oldmode.c_oflag & (TAB3 | ONLCR | OCRNL | ONLRET)) {
+ oldmode.c_oflag &= (TAB3 | ONLCR | OCRNL | ONLRET);
+ tcsetattr(STDERR_FILENO, TCSADRAIN, &oldmode);
+ }
#endif
- settle = set_tabs();
+ settle = set_tabs();
- if (isreset) {
- if ((p = reset_1string) != 0) {
- tputs(p, 0, outc);
- settle = TRUE;
- }
- if ((p = reset_2string) != 0) {
- tputs(p, 0, outc);
- settle = TRUE;
- }
- /* What about rf, rs3, as per terminfo man page? */
- /* also might be nice to send rmacs, rmul, rmm */
- if ((p = reset_file) != 0
- || (p = init_file) != 0) {
- cat(p);
- settle = TRUE;
- }
+ if (isreset) {
+ if ((p = reset_1string) != 0) {
+ tputs(p, 0, outc);
+ settle = TRUE;
}
-
- if (settle) {
- (void)putc('\r', stderr);
- (void)fflush(stderr);
- (void)napms(1000); /* Settle the terminal. */
+ if ((p = reset_2string) != 0) {
+ tputs(p, 0, outc);
+ settle = TRUE;
+ }
+ /* What about rf, rs3, as per terminfo man page? */
+ /* also might be nice to send rmacs, rmul, rmm */
+ if ((p = reset_file) != 0
+ || (p = init_file) != 0) {
+ cat(p);
+ settle = TRUE;
}
+ }
+
+ if (settle) {
+ (void) putc('\r', stderr);
+ (void) fflush(stderr);
+ (void) napms(1000); /* Settle the terminal. */
+ }
}
/*
static bool
set_tabs()
{
- if (set_tab && clear_all_tabs) {
- int c;
-
- (void)putc('\r', stderr); /* Force to left margin. */
- tputs(clear_all_tabs, 0, outc);
-
- for (c = 8; c < tcolumns; c += 8) {
- /* Get to the right column. In BSD tset, this
- * used to try a bunch of half-clever things
- * with cup and hpa, for an average saving of
- * somewhat less than two character times per
- * tab stop, less that .01 sec at 2400cps. We
- * lost all this cruft because it seemed to be
- * introducing some odd bugs.
- * ----------12345678----------- */
- (void)fputs(" ", stderr);
- tputs(set_tab, 0, outc);
- }
- putc('\r', stderr);
- return (TRUE);
+ if (set_tab && clear_all_tabs) {
+ int c;
+
+ (void) putc('\r', stderr); /* Force to left margin. */
+ tputs(clear_all_tabs, 0, outc);
+
+ for (c = 8; c < tcolumns; c += 8) {
+ /* Get to the right column. In BSD tset, this
+ * used to try a bunch of half-clever things
+ * with cup and hpa, for an average saving of
+ * somewhat less than two character times per
+ * tab stop, less that .01 sec at 2400cps. We
+ * lost all this cruft because it seemed to be
+ * introducing some odd bugs.
+ * ----------12345678----------- */
+ (void) fputs(" ", stderr);
+ tputs(set_tab, 0, outc);
}
- return (FALSE);
+ putc('\r', stderr);
+ return (TRUE);
+ }
+ return (FALSE);
}
/**************************************************************************
report(const char *name, int which, unsigned def)
{
#ifdef TERMIOS
- unsigned older, newer;
- char *p;
-
- newer = mode.c_cc[which];
- older = oldmode.c_cc[which];
-
- if (older == newer && older == def)
- return;
-
- (void)fprintf(stderr, "%s %s ", name, older == newer ? "is" : "set to");
-
- /*
- * Check 'delete' before 'backspace', since the key_backspace value
- * is ambiguous.
- */
- if (newer == 0177)
- (void)fprintf(stderr, "delete.\n");
- else if ((p = key_backspace) != 0
- && newer == (unsigned char)p[0]
- && p[1] == '\0')
- (void)fprintf(stderr, "backspace.\n");
- else if (newer < 040) {
- newer ^= 0100;
- (void)fprintf(stderr, "control-%c (^%c).\n", newer, newer);
- } else
- (void)fprintf(stderr, "%c.\n", newer);
+ unsigned older, newer;
+ char *p;
+
+ newer = mode.c_cc[which];
+ older = oldmode.c_cc[which];
+
+ if (older == newer && older == def)
+ return;
+
+ (void) fprintf(stderr, "%s %s ", name, older == newer ? "is" : "set to");
+
+ /*
+ * Check 'delete' before 'backspace', since the key_backspace value
+ * is ambiguous.
+ */
+ if (newer == 0177)
+ (void) fprintf(stderr, "delete.\n");
+ else if ((p = key_backspace) != 0
+ && newer == (unsigned char) p[0]
+ && p[1] == '\0')
+ (void) fprintf(stderr, "backspace.\n");
+ else if (newer < 040) {
+ newer ^= 0100;
+ (void) fprintf(stderr, "control-%c (^%c).\n", newer, newer);
+ } else
+ (void) fprintf(stderr, "%c.\n", newer);
#endif
}
static void
obsolete(char **argv)
{
- for (; *argv; ++argv) {
- char *parm = argv[0];
+ for (; *argv; ++argv) {
+ char *parm = argv[0];
- if (parm[0] == '-' && parm[1] == '\0')
- {
- argv[0] = strdup("-q");
- continue;
- }
+ if (parm[0] == '-' && parm[1] == '\0') {
+ argv[0] = strdup("-q");
+ continue;
+ }
- if ((parm[0] != '-')
- || (argv[1] && argv[1][0] != '-')
- || (parm[1] != 'e' && parm[1] != 'i' && parm[1] != 'k')
- || (parm[2] != '\0'))
- continue;
- switch(argv[0][1]) {
- case 'e':
- argv[0] = strdup("-e^H");
- break;
- case 'i':
- argv[0] = strdup("-i^C");
- break;
- case 'k':
- argv[0] = strdup("-k^U");
- break;
- }
+ if ((parm[0] != '-')
+ || (argv[1] && argv[1][0] != '-')
+ || (parm[1] != 'e' && parm[1] != 'i' && parm[1] != 'k')
+ || (parm[2] != '\0'))
+ continue;
+ switch (argv[0][1]) {
+ case 'e':
+ argv[0] = strdup("-e^H");
+ break;
+ case 'i':
+ argv[0] = strdup("-i^C");
+ break;
+ case 'k':
+ argv[0] = strdup("-k^U");
+ break;
}
+ }
}
static void
-usage(const char* pname)
+usage(const char *pname)
{
- (void)fprintf(stderr,
-"usage: %s [-IQrs] [-] [-e ch] [-i ch] [-k ch] [-m mapping] [terminal]\n", pname);
- exit(EXIT_FAILURE);
+ (void) fprintf(stderr,
+ "usage: %s [-IQrs] [-] [-e ch] [-i ch] [-k ch] [-m mapping] [terminal]\n", pname);
+ exit(EXIT_FAILURE);
}
-static char arg_to_char(void)
+static char
+arg_to_char(void)
{
- return (optarg[0] == '^' && optarg[1] != '\0')
- ? ((optarg[1] == '?') ? '\177' : CTRL(optarg[1]))
- : optarg[0];
+ return (optarg[0] == '^' && optarg[1] != '\0')
+ ? ((optarg[1] == '?') ? '\177' : CTRL(optarg[1]))
+ : optarg[0];
}
int
main(int argc, char **argv)
{
#if defined(TIOCGWINSZ) && defined(TIOCSWINSZ)
- struct winsize win;
+ struct winsize win;
#endif
- int ch, noinit, noset, quiet, Sflag, sflag, showterm;
- const char *p;
- const char *ttype;
+ int ch, noinit, noset, quiet, Sflag, sflag, showterm;
+ const char *p;
+ const char *ttype;
#ifdef __OpenBSD__
- char tcapbuf[1024], *t;
- int tcgetent(char *, const char *);
- void wrtermcap (char *);
-#endif
+ char tcapbuf[1024], *t;
+ int tcgetent(char *, const char *);
+ void wrtermcap (char *);
+#endif /* __OpenBSD__ */
#ifdef TERMIOS
- if (tcgetattr(STDERR_FILENO, &mode) < 0)
- failed("standard error");
+ if (tcgetattr(STDERR_FILENO, &mode) < 0)
+ failed("standard error");
- oldmode = mode;
- ospeed = cfgetospeed(&mode);
+ oldmode = mode;
+ ospeed = cfgetospeed(&mode);
#else
- if (gtty(STDERR_FILENO, &mode) < 0)
- failed("standard error");
+ if (gtty(STDERR_FILENO, &mode) < 0)
+ failed("standard error");
- oldmode = mode;
- ospeed = mode.sg_ospeed;
+ oldmode = mode;
+ ospeed = mode.sg_ospeed;
#endif
- if ((p = strrchr(*argv, '/')) != 0)
- ++p;
- else
- p = *argv;
- if (!CaselessCmp(p, "reset")) {
- isreset = 1;
- reset_mode();
+ if ((p = strrchr(*argv, '/')) != 0)
+ ++p;
+ else
+ p = *argv;
+ if (!CaselessCmp(p, "reset")) {
+ isreset = 1;
+ reset_mode();
+ }
+
+ obsolete(argv);
+ noinit = noset = quiet = Sflag = sflag = showterm = 0;
+ while ((ch = getopt(argc, argv, "a:d:e:Ii:k:m:np:qQSrs")) != -1) {
+ switch (ch) {
+ case 'q': /* display term only */
+ noset = 1;
+ break;
+ case 'a': /* OBSOLETE: map identifier to type */
+ add_mapping("arpanet", optarg);
+ break;
+ case 'd': /* OBSOLETE: map identifier to type */
+ add_mapping("dialup", optarg);
+ break;
+ case 'e': /* erase character */
+ terasechar = arg_to_char();
+ break;
+ case 'I': /* no initialization strings */
+ noinit = 1;
+ break;
+ case 'i': /* interrupt character */
+ intrchar = arg_to_char();
+ break;
+ case 'k': /* kill character */
+ tkillchar = arg_to_char();
+ break;
+ case 'm': /* map identifier to type */
+ add_mapping(0, optarg);
+ break;
+ case 'n': /* OBSOLETE: set new tty driver */
+ break;
+ case 'p': /* OBSOLETE: map identifier to type */
+ add_mapping("plugboard", optarg);
+ break;
+ case 'Q': /* don't output control key settings */
+ quiet = 1;
+ break;
+ case 'S': /* OBSOLETE: output TERM & TERMCAP */
+ Sflag = 1;
+ break;
+ case 'r': /* display term on stderr */
+ showterm = 1;
+ break;
+ case 's': /* output TERM set command */
+ sflag = 1;
+ break;
+ case '?':
+ default:
+ usage(*argv);
}
+ }
+ argc -= optind;
+ argv += optind;
- obsolete(argv);
- noinit = noset = quiet = Sflag = sflag = showterm = 0;
- while ((ch = getopt(argc, argv, "a:d:e:Ii:k:m:np:qQSrs")) != -1) {
- switch (ch) {
- case 'q': /* display term only */
- noset = 1;
- break;
- case 'a': /* OBSOLETE: map identifier to type */
- add_mapping("arpanet", optarg);
- break;
- case 'd': /* OBSOLETE: map identifier to type */
- add_mapping("dialup", optarg);
- break;
- case 'e': /* erase character */
- terasechar = arg_to_char();
- break;
- case 'I': /* no initialization strings */
- noinit = 1;
- break;
- case 'i': /* interrupt character */
- intrchar = arg_to_char();
- break;
- case 'k': /* kill character */
- tkillchar = arg_to_char();
- break;
- case 'm': /* map identifier to type */
- add_mapping(0, optarg);
- break;
- case 'n': /* OBSOLETE: set new tty driver */
- break;
- case 'p': /* OBSOLETE: map identifier to type */
- add_mapping("plugboard", optarg);
- break;
- case 'Q': /* don't output control key settings */
- quiet = 1;
- break;
- case 'S': /* OBSOLETE: output TERM & TERMCAP */
- Sflag = 1;
- break;
- case 'r': /* display term on stderr */
- showterm = 1;
- break;
- case 's': /* output TERM set command */
- sflag = 1;
- break;
- case '?':
- default:
- usage(*argv);
- }
- }
- argc -= optind;
- argv += optind;
+ if (argc > 1)
+ usage(*argv);
- if (argc > 1)
- usage(*argv);
-
- ttype = get_termcap_entry(*argv);
+ ttype = get_termcap_entry(*argv);
#ifdef __OpenBSD__
- if (tcgetent(tcapbuf, ttype) < 0)
- tcapbuf[0] = '\0';
-#endif
+ if (tcgetent(tcapbuf, ttype) < 0)
+ tcapbuf[0] = '\0';
+#endif /* __OpenBSD__ */
- if (!noset) {
- tcolumns = columns;
- tlines = lines;
+ if (!noset) {
+ tcolumns = columns;
+ tlines = lines;
#if defined(TIOCGWINSZ) && defined(TIOCSWINSZ)
- /* Set window size */
- (void)ioctl(STDERR_FILENO, TIOCGWINSZ, &win);
- if (win.ws_row == 0 && win.ws_col == 0 &&
- tlines > 0 && tcolumns > 0) {
- win.ws_row = tlines;
- win.ws_col = tcolumns;
- (void)ioctl(STDERR_FILENO, TIOCSWINSZ, &win);
- }
+ /* Set window size */
+ (void) ioctl(STDERR_FILENO, TIOCGWINSZ, &win);
+ if (win.ws_row == 0 && win.ws_col == 0 &&
+ tlines > 0 && tcolumns > 0) {
+ win.ws_row = tlines;
+ win.ws_col = tcolumns;
+ (void) ioctl(STDERR_FILENO, TIOCSWINSZ, &win);
+ }
#endif
- set_control_chars();
- set_conversions();
+ set_control_chars();
+ set_conversions();
- if (!noinit)
- set_init();
+ if (!noinit)
+ set_init();
- /* Set the modes if they've changed. */
- if (memcmp(&mode, &oldmode, sizeof(mode)))
+ /* Set the modes if they've changed. */
+ if (memcmp(&mode, &oldmode, sizeof(mode)))
#ifdef TERMIOS
- tcsetattr(STDERR_FILENO, TCSADRAIN, &mode);
+ tcsetattr(STDERR_FILENO, TCSADRAIN, &mode);
#else
- stty(STDERR_FILENO, &mode);
+ stty(STDERR_FILENO, &mode);
#endif
- }
+ }
- /* Get the terminal name from the entry. */
- ttype = _nc_first_name(cur_term->type.term_names);
-
- if (noset)
- (void)printf("%s\n", ttype);
- else {
- if (showterm)
- (void)fprintf(stderr, "Terminal type is %s.\n", ttype);
- /*
- * If erase, kill and interrupt characters could have been
- * modified and not -Q, display the changes.
- */
- if (!quiet) {
- report("Erase", VERASE, CERASE);
- report("Kill", VKILL, CINTR);
- report("Interrupt", VINTR, CKILL);
- }
+ /* Get the terminal name from the entry. */
+ ttype = _nc_first_name(cur_term->type.term_names);
+
+ if (noset)
+ (void) printf("%s\n", ttype);
+ else {
+ if (showterm)
+ (void) fprintf(stderr, "Terminal type is %s.\n", ttype);
+ /*
+ * If erase, kill and interrupt characters could have been
+ * modified and not -Q, display the changes.
+ */
+ if (!quiet) {
+ report("Erase", VERASE, CERASE);
+ report("Kill", VKILL, CINTR);
+ report("Interrupt", VINTR, CKILL);
}
+ }
#ifdef __OpenBSD__
- if (Sflag) {
- if (tcapbuf[0]) {
- (void) printf("%s ", ttype);
- wrtermcap(tcapbuf);
- } else
- err("No termcap entry for %s, only terminfo.", ttype);
- }
-#else
- if (Sflag)
- err("The -S option is not supported under terminfo.");
+ if (Sflag) {
+ if (tcapbuf[0]) {
+ (void) printf("%s ", ttype);
+ wrtermcap(tcapbuf);
+ } else
+ err("No termcap entry for %s, only terminfo.", ttype);
+ }
+#else
+ if (Sflag)
+ err("The -S option is not supported under terminfo.");
#endif /* __OpenBSD__ */
#ifdef __OpenBSD__
- if (sflag) {
- /*
- * Figure out what shell we're using. A hack, we look for an
- * environmental variable SHELL ending in "csh".
- */
- if ((p = getenv("SHELL")) != 0
- && !strcmp(p + strlen(p) - 3, "csh")) {
- if (tcapbuf[0])
- p = "set noglob histchars="";\nsetenv TERM %s;\nsetenv TERMCAP ";
- else
- p = "set noglob histchars="";\nsetenv TERM %s;\n";
- t = "unset noglob histchars;\n";
+ if (sflag) {
+ /*
+ * Figure out what shell we're using. A hack, we look for an
+ * environmental variable SHELL ending in "csh".
+ */
+ if ((p = getenv("SHELL")) != 0 && !strcmp(p + strlen(p) - 3, "csh")) {
+ if (tcapbuf[0])
+ p = "set noglob histchars="";\nsetenv TERM %s;\nsetenv TERMCAP ";
+ else
+ p = "set noglob histchars="";\nsetenv TERM %s;\n";
+ t = "unset noglob histchars;\n";
+ } else {
+ if (tcapbuf) {
+ p = "TERM=%s;\nTERMCAP=";
+ t = "export TERMCAP TERM;\n";
+ } else {
+ if (tcapbuf) {
+ p = "TERM=%s;\nTERMCAP=";
+ t = "export TERMCAP TERM;\n";
} else {
- if (tcapbuf) {
- p = "TERM=%s;\nTERMCAP=";
- t = "export TERMCAP TERM;\n";
- } else {
- if (tcapbuf) {
- p = "TERM=%s;\nTERMCAP=";
- t = "export TERMCAP TERM;\n";
- } else {
- p = "TERM=%s;\n";
- t = "export TERMCAP;\n";
- }
- }
+ p = "TERM=%s;\n";
+ t = "export TERMCAP;\n";
}
- (void) printf(p, ttype);
- if (tcapbuf[0]) {
- putchar('\'');
- wrtermcap(tcapbuf);
- fputs("';\n", stdout);
- }
- (void)printf(t);
+ }
}
-#else
- if (sflag) {
- /*
- * Figure out what shell we're using. A hack, we look for an
- * environmental variable SHELL ending in "csh".
- */
- if ((p = getenv("SHELL")) != 0
- && !strcmp(p + strlen(p) - 3, "csh"))
- p = "set noglob;\nsetenv TERM %s;\nunset noglob;\n";
- else
- p = "TERM=%s;\n";
- (void) printf(p, ttype);
+ (void) printf(p, ttype);
+ if (tcapbuf[0]) {
+ putchar('\'');
+ wrtermcap(tcapbuf);
+ fputs("';\n", stdout);
}
+ (void)printf(t);
+ }
+#else
+ if (sflag) {
+ /*
+ * Figure out what shell we're using. A hack, we look for an
+ * environmental variable SHELL ending in "csh".
+ */
+ if ((p = getenv("SHELL")) != 0
+ && !strcmp(p + strlen(p) - 3, "csh"))
+ p = "set noglob;\nsetenv TERM %s;\nunset noglob;\n";
+ else
+ p = "TERM=%s;\n";
+ (void) printf(p, ttype);
+ }
#endif /* __OpenBSD__ */
- return EXIT_SUCCESS;
+ return EXIT_SUCCESS;
}
/* tset.c ends here */
projects / openbsd / commitdiff