URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [services/] [curses/] [pdcurses/] [current/] [src/] [pdcurses/] [getstr.c] - Blame information for rev 786

Details | Compare with Previous | View Log


/* Public Domain Curses */
 
#include <curspriv.h>
 
RCSID("$Id: getstr.c,v 1.1 2009/05/10 08:29:53 jld Exp $")
 
/*man-start**************************************************************
 
  Name:                                                         getstr
 
  Synopsis:
        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);
 
        int get_wstr(wint_t *wstr);
        int wget_wstr(WINDOW *win, wint_t *wstr);
        int mvget_wstr(int y, int x, wint_t *wstr);
        int mvwget_wstr(WINDOW *win, int, int, wint_t *wstr);
        int getn_wstr(wint_t *wstr, int n);
        int wgetn_wstr(WINDOW *win, wint_t *wstr, int n);
        int mvgetn_wstr(int y, int x, wint_t *wstr, int n);
        int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n);
 
  Description:
        These routines call wgetch() repeatedly to build a string,
        interpreting erase and kill characters along the way, until a
        newline or carriage return is received. When PDCurses is built
        with wide-character support enabled, the narrow-character
        functions convert the wgetch()'d values into a multibyte string
        in the current locale before returning it. The resulting string
        is placed in the area pointed to by *str. The routines with n as
        the last argument read at most n characters.
 
        Note that there's no way to know how long the buffer passed to
        wgetstr() is, so use wgetnstr() to avoid buffer overflows.
 
  Return Value:
        This functions return ERR on failure or any other value on
        success.
 
  Portability                                X/Open    BSD    SYS V
        getstr                                  Y       Y       Y
        wgetstr                                 Y       Y       Y
        mvgetstr                                Y       Y       Y
        mvwgetstr                               Y       Y       Y
        getnstr                                 Y       -      4.0
        wgetnstr                                Y       -      4.0
        mvgetnstr                               Y       -       -
        mvwgetnstr                              Y       -       -
        get_wstr                                Y
        wget_wstr                               Y
        mvget_wstr                              Y
        mvwget_wstr                             Y
        getn_wstr                               Y
        wgetn_wstr                              Y
        mvgetn_wstr                             Y
        mvwgetn_wstr                            Y
 
**man-end****************************************************************/
 
#define MAXLINE 255
 
int wgetnstr(WINDOW *win, char *str, int n)
{
#ifdef PDC_WIDE
    wchar_t wstr[MAXLINE + 1];
 
    if (n < 0 || n > MAXLINE)
        n = MAXLINE;
 
    if (wgetn_wstr(win, (wint_t *)wstr, n) == ERR)
        return ERR;
 
    return PDC_wcstombs(str, wstr, n);
#else
    int ch, i, num, x, chars;
    char *p;
    bool stop, oldecho, oldcbreak, oldnodelay;
 
    PDC_LOG(("wgetnstr() - called\n"));
 
    if (!win || !str)
        return ERR;
 
    chars = 0;
    p = str;
    stop = FALSE;
 
    x = win->_curx;
 
    oldcbreak = SP->cbreak; /* remember states */
    oldecho = SP->echo;
    oldnodelay = win->_nodelay;
 
    SP->echo = FALSE;       /* we do echo ourselves */
    cbreak();               /* ensure each key is returned immediately */
    win->_nodelay = FALSE;  /* don't return -1 */
 
    wrefresh(win);
 
    while (!stop)
    {
        ch = wgetch(win);
 
        switch (ch)
        {
 
        case '\t':
            ch = ' ';
            num = TABSIZE - (win->_curx - x) % TABSIZE;
            for (i = 0; i < num; i++)
            {
                if (chars < n)
                {
                    if (oldecho)
                        waddch(win, ch);
                    *p++ = ch;
                    ++chars;
                }
                else
                    beep();
            }
            break;
 
        case _ECHAR:        /* CTRL-H -- Delete character */
            if (p > str)
            {
                if (oldecho)
                    waddstr(win, "\b \b");
                ch = (unsigned char)(*--p);
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
                chars--;
            }
            break;
 
        case _DLCHAR:       /* CTRL-U -- Delete line */
            while (p > str)
            {
                if (oldecho)
                    waddstr(win, "\b \b");
                ch = (unsigned char)(*--p);
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
            }
            chars = 0;
            break;
 
        case _DWCHAR:       /* CTRL-W -- Delete word */
 
            while ((p > str) && (*(p - 1) == ' '))
            {
                if (oldecho)
                    waddstr(win, "\b \b");
 
                --p;        /* remove space */
                chars--;
            }
            while ((p > str) && (*(p - 1) != ' '))
            {
                if (oldecho)
                    waddstr(win, "\b \b");
 
                ch = (unsigned char)(*--p);
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
                chars--;
            }
            break;
 
        case '\n':
        case '\r':
            stop = TRUE;
            if (oldecho)
                waddch(win, '\n');
            break;
 
        default:
            if (chars < n)
            {
                if (!SP->key_code && ch < 0x100)
                {
                    *p++ = ch;
                    if (oldecho)
                        waddch(win, ch);
                    chars++;
                }
            }
            else
                beep();
 
            break;
 
        }
 
        wrefresh(win);
    }
 
    *p = '\0';
 
    SP->echo = oldecho;     /* restore old settings */
    SP->cbreak = oldcbreak;
    win->_nodelay = oldnodelay;
 
    return OK;
#endif
}
 
int getstr(char *str)
{
    PDC_LOG(("getstr() - called\n"));
 
    return wgetnstr(stdscr, str, MAXLINE);
}
 
int wgetstr(WINDOW *win, char *str)
{
    PDC_LOG(("wgetstr() - called\n"));
 
    return wgetnstr(win, str, MAXLINE);
}
 
int mvgetstr(int y, int x, char *str)
{
    PDC_LOG(("mvgetstr() - called\n"));
 
    if (move(y, x) == ERR)
        return ERR;
 
    return wgetnstr(stdscr, str, MAXLINE);
}
 
int mvwgetstr(WINDOW *win, int y, int x, char *str)
{
    PDC_LOG(("mvwgetstr() - called\n"));
 
    if (wmove(win, y, x) == ERR)
        return ERR;
 
    return wgetnstr(win, str, MAXLINE);
}
 
int getnstr(char *str, int n)
{
    PDC_LOG(("getnstr() - called\n"));
 
    return wgetnstr(stdscr, str, n);
}
 
int mvgetnstr(int y, int x, char *str, int n)
{
    PDC_LOG(("mvgetnstr() - called\n"));
 
    if (move(y, x) == ERR)
        return ERR;
 
    return wgetnstr(stdscr, str, n);
}
 
int mvwgetnstr(WINDOW *win, int y, int x, char *str, int n)
{
    PDC_LOG(("mvwgetnstr() - called\n"));
 
    if (wmove(win, y, x) == ERR)
        return ERR;
 
    return wgetnstr(win, str, n);
}
 
#ifdef PDC_WIDE
int wgetn_wstr(WINDOW *win, wint_t *wstr, int n)
{
    int ch, i, num, x, chars;
    wint_t *p;
    bool stop, oldecho, oldcbreak, oldnodelay;
 
    PDC_LOG(("wgetn_wstr() - called\n"));
 
    if (!win || !wstr)
        return ERR;
 
    chars = 0;
    p = wstr;
    stop = FALSE;
 
    x = win->_curx;
 
    oldcbreak = SP->cbreak; /* remember states */
    oldecho = SP->echo;
    oldnodelay = win->_nodelay;
 
    SP->echo = FALSE;       /* we do echo ourselves */
    cbreak();               /* ensure each key is returned immediately */
    win->_nodelay = FALSE;  /* don't return -1 */
 
    wrefresh(win);
 
    while (!stop)
    {
        ch = wgetch(win);
 
        switch (ch)
        {
 
        case '\t':
            ch = ' ';
            num = TABSIZE - (win->_curx - x) % TABSIZE;
            for (i = 0; i < num; i++)
            {
                if (chars < n)
                {
                    if (oldecho)
                        waddch(win, ch);
                    *p++ = ch;
                    ++chars;
                }
                else
                    beep();
            }
            break;
 
        case _ECHAR:        /* CTRL-H -- Delete character */
            if (p > wstr)
            {
                if (oldecho)
                    waddstr(win, "\b \b");
                ch = *--p;
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
                chars--;
            }
            break;
 
        case _DLCHAR:       /* CTRL-U -- Delete line */
            while (p > wstr)
            {
                if (oldecho)
                    waddstr(win, "\b \b");
                ch = *--p;
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
            }
            chars = 0;
            break;
 
        case _DWCHAR:       /* CTRL-W -- Delete word */
 
            while ((p > wstr) && (*(p - 1) == ' '))
            {
                if (oldecho)
                    waddstr(win, "\b \b");
 
                --p;        /* remove space */
                chars--;
            }
            while ((p > wstr) && (*(p - 1) != ' '))
            {
                if (oldecho)
                    waddstr(win, "\b \b");
 
                ch = *--p;
                if ((ch < ' ') && (oldecho))
                    waddstr(win, "\b \b");
                chars--;
            }
            break;
 
        case '\n':
        case '\r':
            stop = TRUE;
            if (oldecho)
                waddch(win, '\n');
            break;
 
        default:
            if (chars < n)
            {
                if (!SP->key_code)
                {
                    *p++ = ch;
                    if (oldecho)
                        waddch(win, ch);
                    chars++;
                }
            }
            else
                beep();
 
            break;
 
        }
 
        wrefresh(win);
    }
 
    *p = '\0';
 
    SP->echo = oldecho;     /* restore old settings */
    SP->cbreak = oldcbreak;
    win->_nodelay = oldnodelay;
 
    return OK;
}
 
int get_wstr(wint_t *wstr)
{
    PDC_LOG(("get_wstr() - called\n"));
 
    return wgetn_wstr(stdscr, wstr, MAXLINE);
}
 
int wget_wstr(WINDOW *win, wint_t *wstr)
{
    PDC_LOG(("wget_wstr() - called\n"));
 
    return wgetn_wstr(win, wstr, MAXLINE);
}
 
int mvget_wstr(int y, int x, wint_t *wstr)
{
    PDC_LOG(("mvget_wstr() - called\n"));
 
    if (move(y, x) == ERR)
        return ERR;
 
    return wgetn_wstr(stdscr, wstr, MAXLINE);
}
 
int mvwget_wstr(WINDOW *win, int y, int x, wint_t *wstr)
{
    PDC_LOG(("mvwget_wstr() - called\n"));
 
    if (wmove(win, y, x) == ERR)
        return ERR;
 
    return wgetn_wstr(win, wstr, MAXLINE);
}
 
int getn_wstr(wint_t *wstr, int n)
{
    PDC_LOG(("getn_wstr() - called\n"));
 
    return wgetn_wstr(stdscr, wstr, n);
}
 
int mvgetn_wstr(int y, int x, wint_t *wstr, int n)
{
    PDC_LOG(("mvgetn_wstr() - called\n"));
 
    if (move(y, x) == ERR)
        return ERR;
 
    return wgetn_wstr(stdscr, wstr, n);
}
 
int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n)
{
    PDC_LOG(("mvwgetn_wstr() - called\n"));
 
    if (wmove(win, y, x) == ERR)
        return ERR;
 
    return wgetn_wstr(win, wstr, n);
}
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [services/] [curses/] [pdcurses/] [current/] [src/] [pdcurses/] [getstr.c] - Blame information for rev 786

Line No.	Rev	Author	Line
1	786	skrzyp	`/* Public Domain Curses */`
2
3			`#include <curspriv.h>`
4
5			`RCSID("$Id: getstr.c,v 1.1 2009/05/10 08:29:53 jld Exp $")`
6
7			`/man-start*************************************************************`
8
9			`Name: getstr`
10
11			`Synopsis:`
12			`int getstr(char *str);`
13			`int wgetstr(WINDOW win, char str);`
14			`int mvgetstr(int y, int x, char *str);`
15			`int mvwgetstr(WINDOW win, int y, int x, char str);`
16			`int getnstr(char *str, int n);`
17			`int wgetnstr(WINDOW win, char str, int n);`
18			`int mvgetnstr(int y, int x, char *str, int n);`
19			`int mvwgetnstr(WINDOW win, int y, int x, char str, int n);`
20
21			`int get_wstr(wint_t *wstr);`
22			`int wget_wstr(WINDOW win, wint_t wstr);`
23			`int mvget_wstr(int y, int x, wint_t *wstr);`
24			`int mvwget_wstr(WINDOW win, int, int, wint_t wstr);`
25			`int getn_wstr(wint_t *wstr, int n);`
26			`int wgetn_wstr(WINDOW win, wint_t wstr, int n);`
27			`int mvgetn_wstr(int y, int x, wint_t *wstr, int n);`
28			`int mvwgetn_wstr(WINDOW win, int y, int x, wint_t wstr, int n);`
29
30			`Description:`
31			`These routines call wgetch() repeatedly to build a string,`
32			`interpreting erase and kill characters along the way, until a`
33			`newline or carriage return is received. When PDCurses is built`
34			`with wide-character support enabled, the narrow-character`
35			`functions convert the wgetch()'d values into a multibyte string`
36			`in the current locale before returning it. The resulting string`
37			`is placed in the area pointed to by *str. The routines with n as`
38			`the last argument read at most n characters.`
39
40			`Note that there's no way to know how long the buffer passed to`
41			`wgetstr() is, so use wgetnstr() to avoid buffer overflows.`
42
43			`Return Value:`
44			`This functions return ERR on failure or any other value on`
45			`success.`
46
47			`Portability X/Open BSD SYS V`
48			`getstr Y Y Y`
49			`wgetstr Y Y Y`
50			`mvgetstr Y Y Y`
51			`mvwgetstr Y Y Y`
52			`getnstr Y - 4.0`
53			`wgetnstr Y - 4.0`
54			`mvgetnstr Y - -`
55			`mvwgetnstr Y - -`
56			`get_wstr Y`
57			`wget_wstr Y`
58			`mvget_wstr Y`
59			`mvwget_wstr Y`
60			`getn_wstr Y`
61			`wgetn_wstr Y`
62			`mvgetn_wstr Y`
63			`mvwgetn_wstr Y`
64
65			`man-end**************************************************************/`
66
67			`#define MAXLINE 255`
68
69			`int wgetnstr(WINDOW win, char str, int n)`
70			`{`
71			`#ifdef PDC_WIDE`
72			`wchar_t wstr[MAXLINE + 1];`
73
74			`if (n < 0 \|\| n > MAXLINE)`
75			`n = MAXLINE;`
76
77			`if (wgetn_wstr(win, (wint_t *)wstr, n) == ERR)`
78			`return ERR;`
79
80			`return PDC_wcstombs(str, wstr, n);`
81			`#else`
82			`int ch, i, num, x, chars;`
83			`char *p;`
84			`bool stop, oldecho, oldcbreak, oldnodelay;`
85
86			`PDC_LOG(("wgetnstr() - called\n"));`
87
88			`if (!win \|\| !str)`
89			`return ERR;`
90
91			`chars = 0;`
92			`p = str;`
93			`stop = FALSE;`
94
95			`x = win->_curx;`
96
97			`oldcbreak = SP->cbreak; /* remember states */`
98			`oldecho = SP->echo;`
99			`oldnodelay = win->_nodelay;`
100
101			`SP->echo = FALSE; /* we do echo ourselves */`
102			`cbreak(); /* ensure each key is returned immediately */`
103			`win->_nodelay = FALSE; /* don't return -1 */`
104
105			`wrefresh(win);`
106
107			`while (!stop)`
108			`{`
109			`ch = wgetch(win);`
110
111			`switch (ch)`
112			`{`
113
114			`case '\t':`
115			`ch = ' ';`
116			`num = TABSIZE - (win->_curx - x) % TABSIZE;`
117			`for (i = 0; i < num; i++)`
118			`{`
119			`if (chars < n)`
120			`{`
121			`if (oldecho)`
122			`waddch(win, ch);`
123			`*p++ = ch;`
124			`++chars;`
125			`}`
126			`else`
127			`beep();`
128			`}`
129			`break;`
130
131			`case _ECHAR: /* CTRL-H -- Delete character */`
132			`if (p > str)`
133			`{`
134			`if (oldecho)`
135			`waddstr(win, "\b \b");`
136			`ch = (unsigned char)(*--p);`
137			`if ((ch < ' ') && (oldecho))`
138			`waddstr(win, "\b \b");`
139			`chars--;`
140			`}`
141			`break;`
142
143			`case _DLCHAR: /* CTRL-U -- Delete line */`
144			`while (p > str)`
145			`{`
146			`if (oldecho)`
147			`waddstr(win, "\b \b");`
148			`ch = (unsigned char)(*--p);`
149			`if ((ch < ' ') && (oldecho))`
150			`waddstr(win, "\b \b");`
151			`}`
152			`chars = 0;`
153			`break;`
154
155			`case _DWCHAR: /* CTRL-W -- Delete word */`
156
157			`while ((p > str) && (*(p - 1) == ' '))`
158			`{`
159			`if (oldecho)`
160			`waddstr(win, "\b \b");`
161
162			`--p; /* remove space */`
163			`chars--;`
164			`}`
165			`while ((p > str) && (*(p - 1) != ' '))`
166			`{`
167			`if (oldecho)`
168			`waddstr(win, "\b \b");`
169
170			`ch = (unsigned char)(*--p);`
171			`if ((ch < ' ') && (oldecho))`
172			`waddstr(win, "\b \b");`
173			`chars--;`
174			`}`
175			`break;`
176
177			`case '\n':`
178			`case '\r':`
179			`stop = TRUE;`
180			`if (oldecho)`
181			`waddch(win, '\n');`
182			`break;`
183
184			`default:`
185			`if (chars < n)`
186			`{`
187			`if (!SP->key_code && ch < 0x100)`
188			`{`
189			`*p++ = ch;`
190			`if (oldecho)`
191			`waddch(win, ch);`
192			`chars++;`
193			`}`
194			`}`
195			`else`
196			`beep();`
197
198			`break;`
199
200			`}`
201
202			`wrefresh(win);`
203			`}`
204
205			`*p = '\0';`
206
207			`SP->echo = oldecho; /* restore old settings */`
208			`SP->cbreak = oldcbreak;`
209			`win->_nodelay = oldnodelay;`
210
211			`return OK;`
212			`#endif`
213			`}`
214
215			`int getstr(char *str)`
216			`{`
217			`PDC_LOG(("getstr() - called\n"));`
218
219			`return wgetnstr(stdscr, str, MAXLINE);`
220			`}`
221
222			`int wgetstr(WINDOW win, char str)`
223			`{`
224			`PDC_LOG(("wgetstr() - called\n"));`
225
226			`return wgetnstr(win, str, MAXLINE);`
227			`}`
228
229			`int mvgetstr(int y, int x, char *str)`
230			`{`
231			`PDC_LOG(("mvgetstr() - called\n"));`
232
233			`if (move(y, x) == ERR)`
234			`return ERR;`
235
236			`return wgetnstr(stdscr, str, MAXLINE);`
237			`}`
238
239			`int mvwgetstr(WINDOW win, int y, int x, char str)`
240			`{`
241			`PDC_LOG(("mvwgetstr() - called\n"));`
242
243			`if (wmove(win, y, x) == ERR)`
244			`return ERR;`
245
246			`return wgetnstr(win, str, MAXLINE);`
247			`}`
248
249			`int getnstr(char *str, int n)`
250			`{`
251			`PDC_LOG(("getnstr() - called\n"));`
252
253			`return wgetnstr(stdscr, str, n);`
254			`}`
255
256			`int mvgetnstr(int y, int x, char *str, int n)`
257			`{`
258			`PDC_LOG(("mvgetnstr() - called\n"));`
259
260			`if (move(y, x) == ERR)`
261			`return ERR;`
262
263			`return wgetnstr(stdscr, str, n);`
264			`}`
265
266			`int mvwgetnstr(WINDOW win, int y, int x, char str, int n)`
267			`{`
268			`PDC_LOG(("mvwgetnstr() - called\n"));`
269
270			`if (wmove(win, y, x) == ERR)`
271			`return ERR;`
272
273			`return wgetnstr(win, str, n);`
274			`}`
275
276			`#ifdef PDC_WIDE`
277			`int wgetn_wstr(WINDOW win, wint_t wstr, int n)`
278			`{`
279			`int ch, i, num, x, chars;`
280			`wint_t *p;`
281			`bool stop, oldecho, oldcbreak, oldnodelay;`
282
283			`PDC_LOG(("wgetn_wstr() - called\n"));`
284
285			`if (!win \|\| !wstr)`
286			`return ERR;`
287
288			`chars = 0;`
289			`p = wstr;`
290			`stop = FALSE;`
291
292			`x = win->_curx;`
293
294			`oldcbreak = SP->cbreak; /* remember states */`
295			`oldecho = SP->echo;`
296			`oldnodelay = win->_nodelay;`
297
298			`SP->echo = FALSE; /* we do echo ourselves */`
299			`cbreak(); /* ensure each key is returned immediately */`
300			`win->_nodelay = FALSE; /* don't return -1 */`
301
302			`wrefresh(win);`
303
304			`while (!stop)`
305			`{`
306			`ch = wgetch(win);`
307
308			`switch (ch)`
309			`{`
310
311			`case '\t':`
312			`ch = ' ';`
313			`num = TABSIZE - (win->_curx - x) % TABSIZE;`
314			`for (i = 0; i < num; i++)`
315			`{`
316			`if (chars < n)`
317			`{`
318			`if (oldecho)`
319			`waddch(win, ch);`
320			`*p++ = ch;`
321			`++chars;`
322			`}`
323			`else`
324			`beep();`
325			`}`
326			`break;`
327
328			`case _ECHAR: /* CTRL-H -- Delete character */`
329			`if (p > wstr)`
330			`{`
331			`if (oldecho)`
332			`waddstr(win, "\b \b");`
333			`ch = *--p;`
334			`if ((ch < ' ') && (oldecho))`
335			`waddstr(win, "\b \b");`
336			`chars--;`
337			`}`
338			`break;`
339
340			`case _DLCHAR: /* CTRL-U -- Delete line */`
341			`while (p > wstr)`
342			`{`
343			`if (oldecho)`
344			`waddstr(win, "\b \b");`
345			`ch = *--p;`
346			`if ((ch < ' ') && (oldecho))`
347			`waddstr(win, "\b \b");`
348			`}`
349			`chars = 0;`
350			`break;`
351
352			`case _DWCHAR: /* CTRL-W -- Delete word */`
353
354			`while ((p > wstr) && (*(p - 1) == ' '))`
355			`{`
356			`if (oldecho)`
357			`waddstr(win, "\b \b");`
358
359			`--p; /* remove space */`
360			`chars--;`
361			`}`
362			`while ((p > wstr) && (*(p - 1) != ' '))`
363			`{`
364			`if (oldecho)`
365			`waddstr(win, "\b \b");`
366
367			`ch = *--p;`
368			`if ((ch < ' ') && (oldecho))`
369			`waddstr(win, "\b \b");`
370			`chars--;`
371			`}`
372			`break;`
373
374			`case '\n':`
375			`case '\r':`
376			`stop = TRUE;`
377			`if (oldecho)`
378			`waddch(win, '\n');`
379			`break;`
380
381			`default:`
382			`if (chars < n)`
383			`{`
384			`if (!SP->key_code)`
385			`{`
386			`*p++ = ch;`
387			`if (oldecho)`
388			`waddch(win, ch);`
389			`chars++;`
390			`}`
391			`}`
392			`else`
393			`beep();`
394
395			`break;`
396
397			`}`
398
399			`wrefresh(win);`
400			`}`
401
402			`*p = '\0';`
403
404			`SP->echo = oldecho; /* restore old settings */`
405			`SP->cbreak = oldcbreak;`
406			`win->_nodelay = oldnodelay;`
407
408			`return OK;`
409			`}`
410
411			`int get_wstr(wint_t *wstr)`
412			`{`
413			`PDC_LOG(("get_wstr() - called\n"));`
414
415			`return wgetn_wstr(stdscr, wstr, MAXLINE);`
416			`}`
417
418			`int wget_wstr(WINDOW win, wint_t wstr)`
419			`{`
420			`PDC_LOG(("wget_wstr() - called\n"));`
421
422			`return wgetn_wstr(win, wstr, MAXLINE);`
423			`}`
424
425			`int mvget_wstr(int y, int x, wint_t *wstr)`
426			`{`
427			`PDC_LOG(("mvget_wstr() - called\n"));`
428
429			`if (move(y, x) == ERR)`
430			`return ERR;`
431
432			`return wgetn_wstr(stdscr, wstr, MAXLINE);`
433			`}`
434
435			`int mvwget_wstr(WINDOW win, int y, int x, wint_t wstr)`
436			`{`
437			`PDC_LOG(("mvwget_wstr() - called\n"));`
438
439			`if (wmove(win, y, x) == ERR)`
440			`return ERR;`
441
442			`return wgetn_wstr(win, wstr, MAXLINE);`
443			`}`
444
445			`int getn_wstr(wint_t *wstr, int n)`
446			`{`
447			`PDC_LOG(("getn_wstr() - called\n"));`
448
449			`return wgetn_wstr(stdscr, wstr, n);`
450			`}`
451
452			`int mvgetn_wstr(int y, int x, wint_t *wstr, int n)`
453			`{`
454			`PDC_LOG(("mvgetn_wstr() - called\n"));`
455
456			`if (move(y, x) == ERR)`
457			`return ERR;`
458
459			`return wgetn_wstr(stdscr, wstr, n);`
460			`}`
461
462			`int mvwgetn_wstr(WINDOW win, int y, int x, wint_t wstr, int n)`
463			`{`
464			`PDC_LOG(("mvwgetn_wstr() - called\n"));`
465
466			`if (wmove(win, y, x) == ERR)`
467			`return ERR;`
468
469			`return wgetn_wstr(win, wstr, n);`
470			`}`
471			`#endif`