X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Fbase%2Flib_set_term.c;h=2b1387ad7a027ddc217821f83bf3511067cc504c;hp=443236cf9cdafadf0e163d846fbf4a65d098876b;hb=aabbbcb7892fd946828a4170378b13b9d12435c6;hpb=0eb88fc5281804773e2a0c7a488a4452463535ce diff --git a/ncurses/base/lib_set_term.c b/ncurses/base/lib_set_term.c index 443236cf..2b1387ad 100644 --- a/ncurses/base/lib_set_term.c +++ b/ncurses/base/lib_set_term.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998-2006,2007 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 * @@ -29,6 +29,7 @@ /**************************************************************************** * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * + * and: Thomas E. Dickey 1996-on * ****************************************************************************/ /* @@ -40,276 +41,591 @@ #include -#include /* cur_term */ +#include /* cur_term */ +#include -MODULE_ID("$Id: lib_set_term.c,v 1.46 1999/07/24 20:05:49 tom Exp $") +MODULE_ID("$Id: lib_set_term.c,v 1.100 2007/09/08 21:23:43 tom Exp $") -SCREEN * set_term(SCREEN *screenp) +NCURSES_EXPORT(SCREEN *) +set_term(SCREEN *screenp) { -SCREEN *oldSP; + SCREEN *oldSP; - T((T_CALLED("set_term(%p)"), screenp)); + T((T_CALLED("set_term(%p)"), screenp)); - oldSP = SP; - _nc_set_screen(screenp); + _nc_lock_global(set_SP); - set_curterm(SP->_term); - curscr = SP->_curscr; - newscr = SP->_newscr; - stdscr = SP->_stdscr; - COLORS = SP->_color_count; - COLOR_PAIRS = SP->_pair_count; - memcpy(acs_map, SP->_acs_map, sizeof(chtype)*ACS_LEN); + oldSP = SP; + _nc_set_screen(screenp); - T((T_RETURN("%p"), oldSP)); - return(oldSP); + set_curterm(SP->_term); +#if !USE_REENTRANT + curscr = SP->_curscr; + newscr = SP->_newscr; + stdscr = SP->_stdscr; + COLORS = SP->_color_count; + COLOR_PAIRS = SP->_pair_count; +#endif + + _nc_unlock_global(set_SP); + + T((T_RETURN("%p"), oldSP)); + return (oldSP); } -static void _nc_free_keytry(struct tries *kt) +static void +_nc_free_keytry(TRIES * kt) { - if (kt != 0) { - _nc_free_keytry(kt->child); - _nc_free_keytry(kt->sibling); - free(kt); - } + if (kt != 0) { + _nc_free_keytry(kt->child); + _nc_free_keytry(kt->sibling); + free(kt); + } } /* * Free the storage associated with the given SCREEN sp. */ -void delscreen(SCREEN *sp) +NCURSES_EXPORT(void) +delscreen(SCREEN *sp) { - SCREEN **scan = &_nc_screen_chain; + SCREEN **scan = &_nc_screen_chain; + int i; - T((T_CALLED("delscreen(%p)"), sp)); + T((T_CALLED("delscreen(%p)"), sp)); - while(*scan) - { - if (*scan == sp) - { - *scan = sp->_next_screen; - break; + _nc_lock_global(set_SP); + while (*scan) { + if (*scan == sp) { + *scan = sp->_next_screen; + break; + } + scan = &(*scan)->_next_screen; + } + + (void) _nc_freewin(sp->_curscr); + (void) _nc_freewin(sp->_newscr); + (void) _nc_freewin(sp->_stdscr); + + if (sp->_slk != 0) { + if (sp->_slk->ent != 0) { + for (i = 0; i < sp->_slk->labcnt; ++i) { + FreeIfNeeded(sp->_slk->ent[i].ent_text); + FreeIfNeeded(sp->_slk->ent[i].form_text); } - scan = &(*scan)->_next_screen; + free(sp->_slk->ent); } + free(sp->_slk); + sp->_slk = 0; + } + + _nc_free_keytry(sp->_keytry); + sp->_keytry = 0; + + _nc_free_keytry(sp->_key_ok); + sp->_key_ok = 0; + + FreeIfNeeded(sp->_current_attr); + + FreeIfNeeded(sp->_color_table); + FreeIfNeeded(sp->_color_pairs); + + FreeIfNeeded(sp->oldhash); + FreeIfNeeded(sp->newhash); + FreeIfNeeded(sp->hashtab); + + FreeIfNeeded(sp->_acs_map); + FreeIfNeeded(sp->_screen_acs_map); + + del_curterm(sp->_term); + + /* + * If the associated output stream has been closed, we can discard the + * set-buffer. Limit the error check to EBADF, since fflush may fail + * for other reasons than trying to operate upon a closed stream. + */ + if (sp->_ofp != 0 + && sp->_setbuf != 0 + && fflush(sp->_ofp) != 0 + && errno == EBADF) { + free(sp->_setbuf); + } + + free(sp); + + /* + * If this was the current screen, reset everything that the + * application might try to use (except cur_term, which may have + * multiple references in different screens). + */ + if (sp == SP) { +#if !USE_REENTRANT + curscr = 0; + newscr = 0; + stdscr = 0; + COLORS = 0; + COLOR_PAIRS = 0; +#endif + _nc_set_screen(0); + } + _nc_unlock_global(set_SP); - _nc_freewin(sp->_curscr); - _nc_freewin(sp->_newscr); - _nc_freewin(sp->_stdscr); - _nc_free_keytry(sp->_keytry); - _nc_free_keytry(sp->_key_ok); + returnVoid; +} - FreeIfNeeded(sp->_color_table); - FreeIfNeeded(sp->_color_pairs); +static bool +no_mouse_event(SCREEN *sp GCC_UNUSED) +{ + return FALSE; +} - FreeIfNeeded(sp->oldhash); - FreeIfNeeded(sp->newhash); +static bool +no_mouse_inline(SCREEN *sp GCC_UNUSED) +{ + return FALSE; +} - del_curterm(sp->_term); +static bool +no_mouse_parse(int code GCC_UNUSED) +{ + return TRUE; +} - free(sp); +static void +no_mouse_resume(SCREEN *sp GCC_UNUSED) +{ +} - /* - * If this was the current screen, reset everything that the - * application might try to use (except cur_term, which may have - * multiple references in different screens). - */ - if (sp == SP) { - curscr = 0; - newscr = 0; - stdscr = 0; - COLORS = 0; - COLOR_PAIRS = 0; - _nc_set_screen(0); - } - returnVoid; +static void +no_mouse_wrap(SCREEN *sp GCC_UNUSED) +{ } -static ripoff_t rippedoff[5]; -static ripoff_t *rsp = rippedoff; -#define N_RIPS SIZEOF(rippedoff) +#if NCURSES_EXT_FUNCS && USE_COLORFGBG +static char * +extract_fgbg(char *src, int *result) +{ + char *dst = 0; + long value = strtol(src, &dst, 0); + + if (dst == 0) { + dst = src; + } else if (value >= 0) { + *result = value; + } + while (*dst != 0 && *dst != ';') + dst++; + if (*dst == ';') + dst++; + return dst; +} +#endif -static bool no_mouse_event (SCREEN *sp GCC_UNUSED) { return FALSE; } -static bool no_mouse_inline(SCREEN *sp GCC_UNUSED) { return FALSE; } -static bool no_mouse_parse (int code GCC_UNUSED) { return TRUE; } -static void no_mouse_resume(SCREEN *sp GCC_UNUSED) { } -static void no_mouse_wrap (SCREEN *sp GCC_UNUSED) { } +#define ripoff_sp _nc_prescreen.rsp +#define ripoff_stack _nc_prescreen.rippedoff -int _nc_setupscreen(short slines, short const scolumns, FILE *output) /* OS-independent screen initializations */ +NCURSES_EXPORT(int) +_nc_setupscreen(int slines GCC_UNUSED, + int scolumns GCC_UNUSED, + FILE *output, + bool filtered, + int slk_format) { -int bottom_stolen = 0; -size_t i; - - assert(SP==0); /* has been reset in newterm() ! */ - if (!_nc_alloc_screen()) - return ERR; - - SP->_next_screen = _nc_screen_chain; - _nc_screen_chain = SP; - - _nc_set_buffer(output, TRUE); - SP->_term = cur_term; - SP->_lines = slines; - SP->_lines_avail = slines; - SP->_columns = scolumns; - SP->_cursrow = -1; - SP->_curscol = -1; - SP->_nl = TRUE; - SP->_raw = FALSE; - SP->_cbreak = 0; - SP->_echo = TRUE; - SP->_fifohead = -1; - SP->_endwin = TRUE; - SP->_ofp = output; - SP->_cursor = -1; /* cannot know real cursor shape */ -#ifdef NCURSES_NO_PADDING - SP->_no_padding = getenv("NCURSES_NO_PADDING") != 0; + int bottom_stolen = 0; + bool support_cookies = USE_XMC_SUPPORT; + ripoff_t *rop; + + T((T_CALLED("_nc_setupscreen(%d, %d, %p, %d, %d)"), + slines, scolumns, output, filtered, slk_format)); + + assert(SP == 0); /* has been reset in newterm() ! */ + if (!_nc_alloc_screen() + || ((SP->_acs_map = typeCalloc(chtype, ACS_LEN)) == 0) + || ((SP->_screen_acs_map = typeCalloc(bool, ACS_LEN)) == 0)) { + returnCode(ERR); + } + + T(("created SP %p", SP)); + SP->_next_screen = _nc_screen_chain; + _nc_screen_chain = SP; + + if ((SP->_current_attr = typeCalloc(NCURSES_CH_T, 1)) == 0) + returnCode(ERR); + + /* + * We should always check the screensize, just in case. + */ + _nc_get_screensize(&slines, &scolumns); + SET_LINES(slines); + SET_COLS(scolumns); + T((T_CREATE("screen %s %dx%d"), termname(), LINES, COLS)); + + SP->_filtered = filtered; + + /* implement filter mode */ + if (filtered) { + slines = 1; + SET_LINES(slines); + clear_screen = 0; + cursor_down = parm_down_cursor = 0; + cursor_address = 0; + cursor_up = parm_up_cursor = 0; + row_address = 0; + + cursor_home = carriage_return; + T(("filter screensize %dx%d", LINES, COLS)); + } +#ifdef __DJGPP__ + T(("setting output mode to binary")); + fflush(output); + setmode(output, O_BINARY); +#endif + _nc_set_buffer(output, TRUE); + SP->_term = cur_term; + SP->_lines = slines; + SP->_lines_avail = slines; + SP->_columns = scolumns; + SP->_cursrow = -1; + SP->_curscol = -1; + SP->_nl = TRUE; + SP->_raw = FALSE; + SP->_cbreak = 0; + SP->_echo = TRUE; + SP->_fifohead = -1; + SP->_endwin = TRUE; + SP->_ofp = output; + SP->_cursor = -1; /* cannot know real cursor shape */ + +#if NCURSES_NO_PADDING + SP->_no_padding = getenv("NCURSES_NO_PADDING") != 0; + TR(TRACE_CHARPUT | TRACE_MOVE, ("padding will%s be used", + SP->_no_padding ? " not" : "")); #endif - SP->_maxclick = DEFAULT_MAXCLICK; - SP->_mouse_event = no_mouse_event; - SP->_mouse_inline = no_mouse_inline; - SP->_mouse_parse = no_mouse_parse; - SP->_mouse_resume = no_mouse_resume; - SP->_mouse_wrap = no_mouse_wrap; - SP->_mouse_fd = -1; +#if NCURSES_EXT_FUNCS + SP->_default_color = FALSE; + SP->_has_sgr_39_49 = FALSE; + + /* + * Set our assumption of the terminal's default foreground and background + * colors. The curs_color man-page states that we can assume that the + * background is black. The origin of this assumption appears to be + * terminals that displayed colored text, but no colored backgrounds, e.g., + * the first colored terminals around 1980. More recent ones with better + * technology can display not only colored backgrounds, but all + * combinations. So a terminal might be something other than "white" on + * black (green/black looks monochrome too), but black on white or even + * on ivory. + * + * White-on-black is the simplest thing to use for monochrome. Almost + * all applications that use color paint both text and background, so + * the distinction is moot. But a few do not - which is why we leave this + * configurable (a better solution is to use assume_default_colors() for + * the rare applications that do require that sort of appearance, since + * is appears that more users expect to be able to make a white-on-black + * or black-on-white display under control of the application than not). + */ +#ifdef USE_ASSUMED_COLOR + SP->_default_fg = COLOR_WHITE; + SP->_default_bg = COLOR_BLACK; +#else + SP->_default_fg = C_MASK; + SP->_default_bg = C_MASK; +#endif - /* initialize the panel hooks */ - SP->_panelHook.top_panel = (struct panel*)0; - SP->_panelHook.bottom_panel = (struct panel*)0; - SP->_panelHook.stdscr_pseudo_panel = (struct panel*)0; + /* + * Allow those assumed/default color assumptions to be overridden at + * runtime: + */ + if (getenv("NCURSES_ASSUMED_COLORS") != 0) { + char *p = getenv("NCURSES_ASSUMED_COLORS"); + int fg, bg; + char sep1, sep2; + int count = sscanf(p, "%d%c%d%c", &fg, &sep1, &bg, &sep2); + if (count >= 1) { + SP->_default_fg = (fg >= 0 && fg < max_colors) ? fg : C_MASK; + if (count >= 3) { + SP->_default_bg = (bg >= 0 && bg < max_colors) ? bg : C_MASK; + } + TR(TRACE_CHARPUT | TRACE_MOVE, + ("from environment assumed fg=%d, bg=%d", + SP->_default_fg, + SP->_default_bg)); + } + } +#if USE_COLORFGBG + /* + * If rxvt's $COLORFGBG variable is set, use it to specify the assumed + * default colors. Note that rxvt (mis)uses bold colors, equating a bold + * color to that value plus 8. We'll only use the non-bold color for now - + * decide later if it is worth having default attributes as well. + */ + if (getenv("COLORFGBG") != 0) { + char *p = getenv("COLORFGBG"); + TR(TRACE_CHARPUT | TRACE_MOVE, ("decoding COLORFGBG %s", p)); + p = extract_fgbg(p, &(SP->_default_fg)); + p = extract_fgbg(p, &(SP->_default_bg)); + if (*p) /* assume rxvt was compiled with xpm support */ + p = extract_fgbg(p, &(SP->_default_bg)); + TR(TRACE_CHARPUT | TRACE_MOVE, ("decoded fg=%d, bg=%d", + SP->_default_fg, SP->_default_bg)); + if (SP->_default_fg >= max_colors) { + if (set_a_foreground != ABSENT_STRING + && !strcmp(set_a_foreground, "\033[3%p1%dm")) { + set_a_foreground = "\033[3%?%p1%{8}%>%t9%e%p1%d%;m"; + } else { + SP->_default_fg %= max_colors; + } + } + if (SP->_default_bg >= max_colors) { + if (set_a_background != ABSENT_STRING + && !strcmp(set_a_background, "\033[4%p1%dm")) { + set_a_background = "\033[4%?%p1%{8}%>%t9%e%p1%d%;m"; + } else { + SP->_default_bg %= max_colors; + } + } + } +#endif +#endif /* NCURSES_EXT_FUNCS */ + + SP->_maxclick = DEFAULT_MAXCLICK; + SP->_mouse_event = no_mouse_event; + SP->_mouse_inline = no_mouse_inline; + SP->_mouse_parse = no_mouse_parse; + SP->_mouse_resume = no_mouse_resume; + SP->_mouse_wrap = no_mouse_wrap; + SP->_mouse_fd = -1; + + /* initialize the panel hooks */ + SP->_panelHook.top_panel = (struct panel *) 0; + SP->_panelHook.bottom_panel = (struct panel *) 0; + SP->_panelHook.stdscr_pseudo_panel = (struct panel *) 0; + + /* + * If we've no magic cookie support, we suppress attributes that xmc would + * affect, i.e., the attributes that affect the rendition of a space. + */ + SP->_ok_attributes = termattrs(); + if (has_colors()) { + SP->_ok_attributes |= A_COLOR; + } +#if USE_XMC_SUPPORT + /* + * If we have no magic-cookie support compiled-in, or if it is suppressed + * in the environment, reset the support-flag. + */ + if (magic_cookie_glitch >= 0) { + if (getenv("NCURSES_NO_MAGIC_COOKIE") != 0) { + support_cookies = FALSE; + } + } +#endif + if (!support_cookies && magic_cookie_glitch >= 0) { + T(("will disable attributes to work w/o magic cookies")); + } + + if (magic_cookie_glitch > 0) { /* tvi, wyse */ + + SP->_xmc_triggers = SP->_ok_attributes & ( + A_STANDOUT | + A_UNDERLINE | + A_REVERSE | + A_BLINK | + A_DIM | + A_BOLD | + A_INVIS | + A_PROTECT + ); +#if 0 /* - * If we've no magic cookie support, we suppress attributes that xmc - * would affect, i.e., the attributes that affect the rendition of a - * space. Note that this impacts the alternate character set mapping - * as well. + * We "should" treat colors as an attribute. The wyse350 (and its + * clones) appear to be the only ones that have both colors and magic + * cookies. */ - if (magic_cookie_glitch > 0) { - - SP->_xmc_triggers = termattrs() & ( - A_ALTCHARSET | - A_BLINK | - A_BOLD | - A_REVERSE | - A_STANDOUT | - A_UNDERLINE - ); - SP->_xmc_suppress = SP->_xmc_triggers & (chtype)~(A_BOLD); - - T(("magic cookie attributes %s", _traceattr(SP->_xmc_suppress))); -#if USE_XMC_SUPPORT - /* - * To keep this simple, suppress all of the optimization hooks - * except for clear_screen and the cursor addressing. - */ - clr_eol = 0; - clr_eos = 0; - set_attributes = 0; -#else - magic_cookie_glitch = -1; - acs_chars = 0; + if (has_colors()) { + SP->_xmc_triggers |= A_COLOR; + } #endif + SP->_xmc_suppress = SP->_xmc_triggers & (chtype) ~(A_BOLD); + + T(("magic cookie attributes %s", _traceattr(SP->_xmc_suppress))); + /* + * Supporting line-drawing may be possible. But make the regular + * video attributes work first. + */ + acs_chars = ABSENT_STRING; + ena_acs = ABSENT_STRING; + enter_alt_charset_mode = ABSENT_STRING; + exit_alt_charset_mode = ABSENT_STRING; +#if USE_XMC_SUPPORT + /* + * To keep the cookie support simple, suppress all of the optimization + * hooks except for clear_screen and the cursor addressing. + */ + if (support_cookies) { + clr_eol = ABSENT_STRING; + clr_eos = ABSENT_STRING; + set_attributes = ABSENT_STRING; } - _nc_init_acs(); - memcpy(SP->_acs_map, acs_map, sizeof(chtype)*ACS_LEN); +#endif + } else if (magic_cookie_glitch == 0) { /* hpterm */ + } + + /* + * If magic cookies are not supported, cancel the strings that set + * video attributes. + */ + if (!support_cookies && magic_cookie_glitch >= 0) { + magic_cookie_glitch = ABSENT_NUMERIC; + set_attributes = ABSENT_STRING; + enter_blink_mode = ABSENT_STRING; + enter_bold_mode = ABSENT_STRING; + enter_dim_mode = ABSENT_STRING; + enter_reverse_mode = ABSENT_STRING; + enter_standout_mode = ABSENT_STRING; + enter_underline_mode = ABSENT_STRING; + } + + /* initialize normal acs before wide, since we use mapping in the latter */ +#if !USE_WIDEC_SUPPORT + if (_nc_unicode_locale() && _nc_locale_breaks_acs()) { + acs_chars = NULL; + ena_acs = NULL; + enter_alt_charset_mode = NULL; + exit_alt_charset_mode = NULL; + set_attributes = NULL; + } +#endif + _nc_init_acs(); +#if USE_WIDEC_SUPPORT + _nc_init_wacs(); + + SP->_screen_acs_fix = (_nc_unicode_locale() && _nc_locale_breaks_acs()); + { + char *env = _nc_get_locale(); + SP->_legacy_coding = ((env == 0) + || !strcmp(env, "C") + || !strcmp(env, "POSIX")); + } +#endif - _nc_idcok = TRUE; - _nc_idlok = FALSE; + _nc_idcok = TRUE; + _nc_idlok = FALSE; - _nc_windows = 0; /* no windows yet */ + _nc_windows = 0; /* no windows yet */ - SP->oldhash = 0; - SP->newhash = 0; + SP->oldhash = 0; + SP->newhash = 0; - T(("creating newscr")); - if ((newscr = newwin(slines, scolumns, 0, 0)) == 0) - return ERR; + T(("creating newscr")); + if ((SP->_newscr = newwin(slines, scolumns, 0, 0)) == 0) + returnCode(ERR); - T(("creating curscr")); - if ((curscr = newwin(slines, scolumns, 0, 0)) == 0) - return ERR; + T(("creating curscr")); + if ((SP->_curscr = newwin(slines, scolumns, 0, 0)) == 0) + returnCode(ERR); - SP->_newscr = newscr; - SP->_curscr = curscr; +#if !USE_REENTRANT + newscr = SP->_newscr; + curscr = SP->_curscr; +#endif #if USE_SIZECHANGE - SP->_resize = resizeterm; + SP->_resize = resizeterm; #endif - newscr->_clear = TRUE; - curscr->_clear = FALSE; - - for (i=0, rsp = rippedoff; rsp->line && (i < N_RIPS); rsp++, i++) { - if (rsp->hook) { - WINDOW *w; - int count = (rsp->line < 0) ? -rsp->line : rsp->line; - - if (rsp->line < 0) { - w = newwin(count,scolumns,SP->_lines_avail - count,0); - if (w) { - rsp->w = w; - rsp->hook(w, scolumns); - bottom_stolen += count; - } - else - return ERR; - } else { - w = newwin(count,scolumns, 0, 0); - if (w) { - rsp->w = w; - rsp->hook(w, scolumns); - SP->_topstolen += count; - } - else - return ERR; - } - SP->_lines_avail -= count; - } - rsp->line = 0; + newscr->_clear = TRUE; + curscr->_clear = FALSE; + + def_shell_mode(); + def_prog_mode(); + + for (rop = ripoff_stack; + rop != ripoff_sp && (rop - ripoff_stack) < N_RIPS; + rop++) { + + /* If we must simulate soft labels, grab off the line to be used. + We assume that we must simulate, if it is none of the standard + formats (4-4 or 3-2-3) for which there may be some hardware + support. */ + if (rop->hook == _nc_slk_initialize) + if (!(num_labels <= 0 || !SLK_STDFMT(slk_format))) + continue; + if (rop->hook) { + int count; + WINDOW *w; + + count = (rop->line < 0) ? -rop->line : rop->line; + T(("ripping off %i lines at %s", count, + ((rop->line < 0) + ? "bottom" + : "top"))); + + w = newwin(count, scolumns, + ((rop->line < 0) + ? SP->_lines_avail - count + : 0), + 0); + if (w) + rop->hook(w, scolumns); + else + returnCode(ERR); + if (rop->line < 0) + bottom_stolen += count; + else + SP->_topstolen += count; + SP->_lines_avail -= count; } - /* reset the stack */ - rsp = rippedoff; - - T(("creating stdscr")); - assert ((SP->_lines_avail + SP->_topstolen + bottom_stolen) == slines); - if ((stdscr = newwin(LINES = SP->_lines_avail, scolumns, 0, 0)) == 0) - return ERR; - SP->_stdscr = stdscr; - - def_shell_mode(); - def_prog_mode(); + } + /* reset the stack */ + ripoff_sp = ripoff_stack; + + T(("creating stdscr")); + assert((SP->_lines_avail + SP->_topstolen + bottom_stolen) == slines); + if ((SP->_stdscr = newwin(SP->_lines_avail, scolumns, 0, 0)) == 0) + returnCode(ERR); + + SET_LINES(SP->_lines_avail); +#if !USE_REENTRANT + stdscr = SP->_stdscr; +#endif - return OK; + returnCode(OK); } -/* The internal implementation interprets line as the number of - lines to rip off from the top or bottom. - */ -int -_nc_ripoffline(int line, int (*init)(WINDOW *,int)) +/* + * The internal implementation interprets line as the number of lines to rip + * off from the top or bottom. + */ +NCURSES_EXPORT(int) +_nc_ripoffline(int line, int (*init) (WINDOW *, int)) { - if (line == 0) - return(OK); + T((T_CALLED("_nc_ripoffline(%d, %p)"), line, init)); + + if (line != 0) { - if (rsp >= rippedoff + N_RIPS) - return(ERR); + if (ripoff_sp == 0) + ripoff_sp = ripoff_stack; + if (ripoff_sp >= ripoff_stack + N_RIPS) + returnCode(ERR); - rsp->line = line; - rsp->hook = init; - rsp->w = 0; - rsp++; + ripoff_sp->line = line; + ripoff_sp->hook = init; + ripoff_sp++; + } - return(OK); + returnCode(OK); } -int -ripoffline(int line, int (*init)(WINDOW *, int)) +NCURSES_EXPORT(int) +ripoffline(int line, int (*init) (WINDOW *, int)) { T((T_CALLED("ripoffline(%d,%p)"), line, init)); if (line == 0) returnCode(OK); - returnCode(_nc_ripoffline ((line<0) ? -1 : 1, init)); + returnCode(_nc_ripoffline((line < 0) ? -1 : 1, init)); }