# curs_getstr 3x 2025-07-05 ncurses 6.5 Library calls

    curs_getstr(3x)                  Library calls                 curs_getstr(3x)

## NAME

           getstr,  getnstr,  wgetstr,  wgetnstr,  mvgetstr, mvgetnstr, mvwgetstr,
           mvwgetnstr - read a character string from curses terminal keyboard

## SYNOPSIS

           #include <curses.h>

           int getstr(char * str);
           int wgetstr(WINDOW * win, char * str);
           int mvgetstr(int y, int x, char * str);
           int mvwgetstr(WINDOW * win, int y, int x, char * str);

           int getnstr(char * str, int n);
           int wgetnstr(WINDOW * win, char * str, int n);
           int mvgetnstr(int y, int x, char * str, int n);
           int mvwgetnstr(WINDOW * win, int y, int x, char * str,
                 int n);

## DESCRIPTION

           wgetstr populates a  user-supplied  string  buffer  str  by  repeatedly
           calling  wgetch(3x) with the win argument until a line feed or carriage
           return character is input.  The function

           o   does not copy the terminating character to str;

           o   always terminates str with a null character;

           o   interprets  the   screen's   erase   and   kill   characters   (see
               erasechar(3x) and killchar(3x));

           o   recognizes  function  keys  only  if  the screen's keypad option is
               enabled (see keypad(3x));

           o   treats the function keys KEY_LEFT and KEY_BACKSPACE the same as the
               erase character; and

           o   discards  function key inputs other than those treated as the erase
               or kill characters, calling beep(3x).

           If any characters have been written to  the  input  buffer,  the  erase
           character  replaces the character at the current position in the buffer
           with a null character, then decrements the position by  one;  the  kill
           character  does  the  same repeatedly, backtracking to the beginning of
           the buffer.

           If the screen's echo option is enabled (see echo(3x)), wgetstr  updates
           win with waddch(3x).  Further,

           o   the  erase  character and its function key synonyms move the cursor
               to the left (if not already where it was located when  wgetstr  was
               called) and

           o   the  kill character returns the cursor to where it was located when
               wgetstr was called.

           wgetnstr is similar,  but  reads  at  most  n  characters,  aiding  the
           application  to  avoid  overrunning  the  buffer  to  which str points.
           curses ignores an attempt to input more than n characters  (other  than
           the  terminating line feed or carriage return), calling beep(3x).  If n
           is  negative,  wgetn_wstr  reads  up  to   LINE_MAX   characters   (see
           sysconf(3)).

           ncurses(3x) describes the variants of these functions.

## RETURN VALUE

           These functions return OK on success and ERR on failure.

           In ncurses, these functions fail if

           o   the curses screen has not been initialized,

           o   (for  functions  taking  a  WINDOW  pointer argument) win is a null
               pointer,

           o   str is a null pointer, or

           o   an internal wgetch(3x) call fails.

           Further, in ncurses, these functions return KEY_RESIZE  if  a  SIGWINCH
           event interrupts the function.

           Functions  prefixed with "mv" first perform cursor movement and fail if
           the position (y, x) is outside the window boundaries.

## NOTES

           All of these functions except wgetnstr may be implemented as macros.

           Reading input that  overruns  the  buffer  pointed  to  by  str  causes
           undefined   results.    Use   the  n-infixed  functions,  and  allocate
           sufficient storage for str -- at least n+1 times sizeof(char).

           While these functions conceptually  implement  a  series  of  calls  to
           wgetch, they also temporarily change properties of the curses screen to
           permit simple editing of the input buffer.   Each  function  saves  the
           screen's  state,  calls  nl(3x),  and,  if  the screen was in canonical
           ("cooked") mode, cbreak(3x).  Before returning, it restores  the  saved
           screen  state.  Other implementations differ in detail, affecting which
           control  characters  they  can  accept  in  the  buffer;  see   section
           "PORTABILITY" below.

## EXTENSIONS

           getnstr,  wgetnstr,  mvgetnstr,  and mvwgetnstr's handing of negative n
           values is an ncurses extension.

           The return value KEY_RESIZE is an ncurses extension.

## PORTABILITY

           Applications employing ncurses extensions should condition their use on
           the visibility of the NCURSES_VERSION preprocessor macro.

           X/Open Curses Issue 4 describes these functions.  It specifies no error
           conditions for them, but indicates that wgetnstr and its variants  read
           "the entire multi-byte sequence associated with a character" and "fail"
           if n and str together do not describe a buffer "large enough to contain
           any  complete  characters".   In  ncurses,  however,  wgetch reads only
           single-byte characters, so this scenario does not arise.

           SVr4 describes a successful return value  only  as  "an  integer  value
           other than ERR".

           SVr3  and  early  SVr4  curses  implementations did not reject function
           keys; the SVr4 documentation asserted that, like the screen's erase and
           kill characters, they were

                  interpreted, as well as any special keys (such as function keys,
                  "home" key, "clear" key, etc.)

           without further detail.  It lied.  The "character"  value  appended  to
           the  string  by those implementations was predictable but not useful --
           being, in fact, the  low-order  eight  bits  of  the  key  code's  KEY_
           constant  value.   (The  same  language,  unchanged except for styling,
           survived into X/Open Curses Issue 4,  Version 2  but  disappeared  from
           Issue 7.)

           A draft of X/Open Curses Issue 5 (which never saw final release) stated
           that these functions "read at most n bytes" but did not  state  whether
           the  terminating  null  character  counted  toward  that limit.  X/Open
           Curses Issue 7 changed that to say they "read at  most  n-1  bytes"  to
           allow   for   the   terminating  null  character.   As  of  2018,  some
           implementations count it, some do not.

           o   ncurses 6.1 and PDCurses do not count the null character toward the
               limit, while Solaris and NetBSD curses do.

           o   Solaris   xcurses   offers   both   behaviors:  its  wide-character
               wgetn_wstr reserves room for a wide null character,  but  its  non-
               wide  wgetnstr  does not consistently count a null character toward
               the limit.

           X/Open Curses does  not  specify  what  happens  if  the  length  n  is
           negative.

           o   ncurses  6.2  uses  LINE_MAX  or  a larger (system-dependent) value
               provided  by  sysconf(3).   If  neither  LINE_MAX  nor  sysconf  is
               available,  ncurses  uses  the  POSIX  minimum  value  for LINE_MAX
               (2048).  In either case, it reserves a  byte  for  the  terminating
               null character.

           o   In  SVr4  curses,  a  negative  n tells wgetnstr to assume that the
               caller's buffer is large enough to hold the result;  that  is,  the
               function  then  acts  like wgetstr.  X/Open Curses does not mention
               this behavior  (or  anything  related  to  nonpositive  n  values),
               however  most  curses libraries implement it.  Most implementations
               nevertheless enforce an upper limit on  the  count  of  bytes  they
               write to the destination buffer str.

           o   BSD   curses   lacked  wgetnstr,  and  its  wgetstr  wrote  to  str
               unboundedly, as did that in SVr2.

           o   PDCurses, and  SVr3  and  later,  and  Solaris  curses  limit  both
               functions  to  writing  256  bytes.  Other System V-based platforms
               likely use the same limit.

           o   Solaris  xcurses  limits  the  write   to   LINE_MAX   bytes   (see
               sysconf(3)).

           o   NetBSD  7  curses  imposes no particular limit on the length of the
               write, but does validate n to ensure that it is greater than  zero.
               A  comment  in  NetBSD's  source  code asserts that SUSv2 specifies
               this.

           Implementations vary in their handling of input control characters.

           o   While they may enable the screen's echo option, some do not take it
               out  of  raw  mode,  and  may  take  cbreak  mode into account when
               deciding whether to handle echoing within wgetnstr or to rely on it
               as a side effect of calling wgetch.

           o   Originally,  ncurses, like its progenitor pcurses, had its wgetnstr
               call noraw and cbreak before accepting input.  That may  have  been
               done  to  make  function keys work; it is not necessary with modern
               ncurses.

               Since 1995, ncurses has provided handlers for SIGINTR  and  SIGQUIT
               events,  which  are typically generated at the keyboard with ^C and
               ^\ respectively.  In cbreak mode, those handlers catch a signal and
               stop   the  program,  whereas  other  implementations  write  those
               characters into the buffer.

           o   Starting with ncurses 6.3 (2021), wgetnstr preserves  raw  mode  if
               the  screen  was  already  in that state, allowing one to enter the
               characters the terminal interprets as  interrupt  and  quit  events
               into the buffer, for better compatibility with SVr4 curses.

## HISTORY

           4BSD (1980) introduced wgetstr along with its variants.

           SVr3.1 (1987) added wgetnstr, but none of its variants.

           X/Open   Curses   Issue 4  (1995)  specified  getnstr,  mvgetnstr,  and
           mvwgetnstr.

## SEE ALSO

           curs_get_wstr(3x) describes comparable functions of the ncurses library
           in its wide-character configuration (ncursesw).

           curses(3x),     curs_addch(3x),     curs_getch(3x),    curs_inopts(3x),
           curs_termattrs(3x),

    ncurses 6.5                       2025-07-05                   curs_getstr(3x)