X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftinfo%2Flib_tputs.c;h=4b89a19ed9ddd1b97607cef676a921960dd69a06;hp=6cadbca19003a24e17f4e12c148a29fb4ccc4695;hb=7f4b9f390624835ceb0849965a7f6ff2dcb39d00;hpb=d4ede7c5fa6a269d338fea32cd93bf39083dda8c diff --git a/ncurses/tinfo/lib_tputs.c b/ncurses/tinfo/lib_tputs.c index 6cadbca1..4b89a19e 100644 --- a/ncurses/tinfo/lib_tputs.c +++ b/ncurses/tinfo/lib_tputs.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998-2008,2009 Free Software Foundation, Inc. * + * Copyright 2018-2020,2021 Thomas E. Dickey * + * Copyright 1998-2016,2017 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 * @@ -51,7 +52,7 @@ #include /* ospeed */ #include -MODULE_ID("$Id: lib_tputs.c,v 1.75 2009/05/30 19:44:43 tom Exp $") +MODULE_ID("$Id: lib_tputs.c,v 1.107 2021/04/03 18:45:53 tom Exp $") NCURSES_EXPORT_VAR(char) PC = 0; /* used by termcap library */ NCURSES_EXPORT_VAR(NCURSES_OSPEED) ospeed = 0; /* used by termcap library */ @@ -75,15 +76,18 @@ _nc_set_no_padding(SCREEN *sp) #endif #if NCURSES_SP_FUNCS -#define my_outch SP_PARM->_outch +#define SetOutCh(func) if (SP_PARM) SP_PARM->_outch = func; else _nc_prescreen._outch = func +#define GetOutCh() (SP_PARM ? SP_PARM->_outch : _nc_prescreen._outch) #else -static NCURSES_SP_OUTC my_outch = NCURSES_SP_NAME(_nc_outch); +#define SetOutCh(func) static_outch = func +#define GetOutCh() static_outch +static NCURSES_SP_OUTC static_outch = NCURSES_SP_NAME(_nc_outch); #endif NCURSES_EXPORT(int) NCURSES_SP_NAME(delay_output) (NCURSES_SP_DCLx int ms) { - T((T_CALLED("delay_output(%p,%d)"), SP_PARM, ms)); + T((T_CALLED("delay_output(%p,%d)"), (void *) SP_PARM, ms)); if (!HasTInfoTerminal(SP_PARM)) returnCode(ERR); @@ -92,6 +96,7 @@ NCURSES_SP_NAME(delay_output) (NCURSES_SP_DCLx int ms) NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG); napms(ms); } else { + NCURSES_SP_OUTC my_outch = GetOutCh(); register int nullcount; nullcount = (ms * _nc_baudrate(ospeed)) / (BAUDBYTE * 1000); @@ -115,7 +120,42 @@ delay_output(int ms) NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_DCL0) { - (void) fflush(NC_OUTPUT(SP_PARM)); + T((T_CALLED("_nc_flush(%p)"), (void *) SP_PARM)); + if (SP_PARM != 0 && SP_PARM->_ofd >= 0) { + TR(TRACE_CHARPUT, ("ofd:%d inuse:%lu buffer:%p", + SP_PARM->_ofd, + (unsigned long) SP_PARM->out_inuse, + SP_PARM->out_buffer)); + if (SP_PARM->out_inuse) { + char *buf = SP_PARM->out_buffer; + size_t amount = SP->out_inuse; + + SP->out_inuse = 0; + TR(TRACE_CHARPUT, ("flushing %ld/%ld bytes", + (unsigned long) amount, _nc_outchars)); + while (amount) { + ssize_t res = write(SP_PARM->_ofd, buf, amount); + if (res > 0) { + /* if the write was incomplete, try again */ + amount -= (size_t) res; + buf += res; + } else if (errno == EAGAIN) { + continue; + } else if (errno == EINTR) { + continue; + } else { + break; /* an error we can not recover from */ + } + } + } else if (SP_PARM->out_buffer == 0) { + TR(TRACE_CHARPUT, ("flushing stdout")); + fflush(stdout); + } + } else { + TR(TRACE_CHARPUT, ("flushing stdout")); + fflush(stdout); + } + returnVoid; } #if NCURSES_SP_FUNCS @@ -129,20 +169,31 @@ _nc_flush(void) NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_outch) (NCURSES_SP_DCLx int ch) { + int rc = OK; + COUNT_OUTCHARS(1); if (HasTInfoTerminal(SP_PARM) - && SP_PARM->_cleanup) { - char tmp = ch; - /* - * POSIX says write() is safe in a signal handler, but the - * buffered I/O is not. - */ - write(fileno(NC_OUTPUT(SP_PARM)), &tmp, 1); + && SP_PARM != 0) { + if (SP_PARM->out_buffer != 0) { + if (SP_PARM->out_inuse + 1 >= SP_PARM->out_limit) + NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG); + SP_PARM->out_buffer[SP_PARM->out_inuse++] = (char) ch; + } else { + char tmp = (char) ch; + /* + * POSIX says write() is safe in a signal handler, but the + * buffered I/O is not. + */ + if (write(fileno(NC_OUTPUT(SP_PARM)), &tmp, (size_t) 1) == -1) + rc = ERR; + } } else { - putc(ch, NC_OUTPUT(SP_PARM)); + char tmp = (char) ch; + if (write(fileno(stdout), &tmp, (size_t) 1) == -1) + rc = ERR; } - return OK; + return rc; } #if NCURSES_SP_FUNCS @@ -153,13 +204,48 @@ _nc_outch(int ch) } #endif +/* + * This is used for the putp special case. + */ +NCURSES_EXPORT(int) +NCURSES_SP_NAME(_nc_putchar) (NCURSES_SP_DCLx int ch) +{ + (void) SP_PARM; + return putchar(ch); +} + +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +_nc_putchar(int ch) +{ + return putchar(ch); +} +#endif + +/* + * putp is special - per documentation it calls tputs with putchar as the + * parameter for outputting characters. This means that it uses stdio, which + * is not signal-safe. Applications call this entrypoint; we do not call it + * from within the library. + */ NCURSES_EXPORT(int) NCURSES_SP_NAME(putp) (NCURSES_SP_DCLx const char *string) { return NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx - string, 1, NCURSES_SP_NAME(_nc_outch)); + string, 1, NCURSES_SP_NAME(_nc_putchar)); +} + +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +putp(const char *string) +{ + return NCURSES_SP_NAME(putp) (CURRENT_SCREEN, string); } +#endif +/* + * Use these entrypoints rather than "putp" within the library. + */ NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_DCLx const char *name GCC_UNUSED, @@ -169,18 +255,13 @@ NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_DCLx if (string != 0) { TPUTS_TRACE(name); - rc = NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx string); + rc = NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx + string, 1, NCURSES_SP_NAME(_nc_outch)); } return rc; } #if NCURSES_SP_FUNCS -NCURSES_EXPORT(int) -putp(const char *string) -{ - return NCURSES_SP_NAME(putp) (CURRENT_SCREEN, string); -} - NCURSES_EXPORT(int) _nc_putp(const char *name, const char *string) { @@ -194,6 +275,7 @@ NCURSES_SP_NAME(tputs) (NCURSES_SP_DCLx int affcnt, NCURSES_SP_OUTC outc) { + NCURSES_SP_OUTC my_outch = GetOutCh(); bool always_delay; bool normal_delay; int number; @@ -202,13 +284,16 @@ NCURSES_SP_NAME(tputs) (NCURSES_SP_DCLx #endif /* BSD_TPUTS */ #ifdef TRACE - char addrbuf[32]; - if (USE_TRACEF(TRACE_TPUTS)) { - if (outc == NCURSES_SP_NAME(_nc_outch)) - (void) strcpy(addrbuf, "_nc_outch"); - else - (void) sprintf(addrbuf, "%p", outc); + char addrbuf[32]; + TR_FUNC_BFR(1); + + if (outc == NCURSES_SP_NAME(_nc_outch)) { + _nc_STRCPY(addrbuf, "_nc_outch", sizeof(addrbuf)); + } else { + _nc_SPRINTF(addrbuf, _nc_SLIMIT(sizeof(addrbuf)) "%s", + TR_FUNC_ARG(0, outc)); + } if (_nc_tputs_trace) { _tracef("tputs(%s = %s, %d, %s) called", _nc_tputs_trace, _nc_visbuf(string), affcnt, addrbuf); @@ -226,7 +311,13 @@ NCURSES_SP_NAME(tputs) (NCURSES_SP_DCLx if (!VALID_STRING(string)) return ERR; - if (SP_PARM != 0 && SP_PARM->_term == 0) { + if ( +#if NCURSES_SP_FUNCS + (SP_PARM != 0 && SP_PARM->_term == 0) +#else + cur_term == 0 +#endif + ) { always_delay = FALSE; normal_delay = TRUE; } else { @@ -269,7 +360,7 @@ NCURSES_SP_NAME(tputs) (NCURSES_SP_DCLx } #endif /* BSD_TPUTS */ - my_outch = outc; /* redirect delay_output() */ + SetOutCh(outc); /* redirect delay_output() */ while (*string) { if (*string != '$') (*outc) (NCURSES_SP_ARGx *string); @@ -338,10 +429,10 @@ NCURSES_SP_NAME(tputs) (NCURSES_SP_DCLx */ if (trailpad > 0 && (always_delay || normal_delay)) - delay_output(trailpad / 10); + NCURSES_SP_NAME(delay_output) (NCURSES_SP_ARGx trailpad / 10); #endif /* BSD_TPUTS */ - my_outch = NCURSES_SP_NAME(_nc_outch); + SetOutCh(my_outch); return OK; } @@ -350,7 +441,7 @@ NCURSES_EXPORT(int) _nc_outc_wrapper(SCREEN *sp, int c) { if (0 == sp) { - return (ERR); + return fputc(c, stdout); } else { return sp->jump(c); }