Back to index

tetex-bin  3.0
Functions
lib_tputs.c File Reference
#include <curses.priv.h>
#include <ctype.h>
#include <term.h>
#include <termcap.h>
#include <tic.h>

Go to the source code of this file.

Functions

 NCURSES_EXPORT_VAR (char)
 _nc_flush (void)
 _nc_outch (int ch)
 putp (const char *string)
 tputs (const char *string, int affcnt, int(*outc)(int))

Function Documentation

_nc_flush ( void  )

Definition at line 79 of file lib_tputs.c.

Here is the call graph for this function:

Here is the caller graph for this function:

_nc_outch ( int  ch)

Definition at line 85 of file lib_tputs.c.

{
    TRACE_OUTCHARS(1);

    if (SP != 0
       && SP->_cleanup) {
       char tmp = ch;
       /*
        * POSIX says write() is safe in a signal handler, but the
        * buffered I/O is not.
        */
       write(fileno(NC_OUTPUT), &tmp, 1);
    } else {
       putc(ch, NC_OUTPUT);
    }
    return OK;
}

Here is the caller graph for this function:

NCURSES_EXPORT_VAR ( char  )

Definition at line 50 of file lib_tputs.c.

{
    T((T_CALLED("delay_output(%d)"), ms));

    if (no_pad_char) {
       _nc_flush();
       napms(ms);
    } else {
       register int nullcount;

       nullcount = (ms * _nc_baudrate(ospeed)) / (BAUDBYTE * 1000);
       for (_nc_nulls_sent += nullcount; nullcount > 0; nullcount--)
           my_outch(PC);
       if (my_outch == _nc_outch)
           _nc_flush();
    }

    returnCode(OK);
}

Here is the call graph for this function:

putp ( const char *  string)

Definition at line 104 of file lib_tputs.c.

{
    return tputs(string, 1, _nc_outch);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tputs ( const char *  string,
int  affcnt,
int(*)(int outc 
)

Definition at line 110 of file lib_tputs.c.

{
    bool always_delay;
    bool normal_delay;
    int number;
#if BSD_TPUTS
    int trailpad;
#endif /* BSD_TPUTS */

#ifdef TRACE
    char addrbuf[32];

    if (_nc_tracing & TRACE_TPUTS) {
       if (outc == _nc_outch)
           (void) strcpy(addrbuf, "_nc_outch");
       else
           (void) sprintf(addrbuf, "%p", outc);
       if (_nc_tputs_trace) {
           _tracef("tputs(%s = %s, %d, %s) called", _nc_tputs_trace,
                  _nc_visbuf(string), affcnt, addrbuf);
       } else {
           _tracef("tputs(%s, %d, %s) called", _nc_visbuf(string), affcnt, addrbuf);
       }
       _nc_tputs_trace = (char *) NULL;
    }
#endif /* TRACE */

    if (!VALID_STRING(string))
       return ERR;

    if (cur_term == 0) {
       always_delay = FALSE;
       normal_delay = TRUE;
    } else {
       always_delay = (string == bell) || (string == flash_screen);
       normal_delay =
           !xon_xoff
           && padding_baud_rate
#if NCURSES_NO_PADDING
           && (SP == 0 || !(SP->_no_padding))
#endif
           && (_nc_baudrate(ospeed) >= padding_baud_rate);
    }

#if BSD_TPUTS
    /*
     * This ugly kluge deals with the fact that some ancient BSD programs
     * (like nethack) actually do the likes of tputs("50") to get delays.
     */
    trailpad = 0;
    if (isdigit(UChar(*string))) {
       while (isdigit(UChar(*string))) {
           trailpad = trailpad * 10 + (*string - '0');
           string++;
       }
       trailpad *= 10;
       if (*string == '.') {
           string++;
           if (isdigit(UChar(*string))) {
              trailpad += (*string - '0');
              string++;
           }
           while (isdigit(UChar(*string)))
              string++;
       }

       if (*string == '*') {
           trailpad *= affcnt;
           string++;
       }
    }
#endif /* BSD_TPUTS */

    my_outch = outc;        /* redirect delay_output() */
    while (*string) {
       if (*string != '$')
           (*outc) (*string);
       else {
           string++;
           if (*string != '<') {
              (*outc) ('$');
              if (*string)
                  (*outc) (*string);
           } else {
              bool mandatory;

              string++;
              if ((!isdigit(UChar(*string)) && *string != '.')
                  || !strchr(string, '>')) {
                  (*outc) ('$');
                  (*outc) ('<');
                  continue;
              }

              number = 0;
              while (isdigit(UChar(*string))) {
                  number = number * 10 + (*string - '0');
                  string++;
              }
              number *= 10;
              if (*string == '.') {
                  string++;
                  if (isdigit(UChar(*string))) {
                     number += (*string - '0');
                     string++;
                  }
                  while (isdigit(UChar(*string)))
                     string++;
              }

              mandatory = FALSE;
              while (*string == '*' || *string == '/') {
                  if (*string == '*') {
                     number *= affcnt;
                     string++;
                  } else {  /* if (*string == '/') */
                     mandatory = TRUE;
                     string++;
                  }
              }

              if (number > 0
                  && (always_delay
                     || normal_delay
                     || mandatory))
                  delay_output(number / 10);

           }                /* endelse (*string == '<') */
       }                    /* endelse (*string == '$') */

       if (*string == '\0')
           break;

       string++;
    }

#if BSD_TPUTS
    /*
     * Emit any BSD-style prefix padding that we've accumulated now.
     */
    if (trailpad > 0
       && (always_delay || normal_delay))
       delay_output(trailpad / 10);
#endif /* BSD_TPUTS */

    my_outch = _nc_outch;
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: