libpayload: Add PDCurses and ncurses' libform/libmenu

PDCurses provides an alternative implementation of the curses library
standard in addition to tinycurses.
Where tinycurses is really tiny, PDCurses is more complete and provides
virtually unlimited windows and the full API.
The PDCurses code is brought in "vanilla", with all local changes
residing in curses/pdcurses-backend/

In addition to a curses library, this change also provides libpanel (as
part of the PDCurses code), and libform and libmenu which were derived
from ncurses-5.9.
As they rely on ncurses internals (and PDCurses is not ncurses), more
changes were required for these libraries to work.

The build system is extended to install the right set of header files
depending on the selected curses implementation.

Change-Id: I9e5b920f94b6510da01da2f656196a993170d1c5
Signed-off-by: Patrick Georgi <patrick.georgi@secunet.com>
Reviewed-on: http://review.coreboot.org/106
Tested-by: build bot (Jenkins)
Reviewed-by: Marc Jones <marcj303@gmail.com>

1 files changed, 321 insertions, 0 deletions

diff --git a/payloads/libpayload/curses/PDCurses-3.4/pdcurses/inopts.c b/payloads/libpayload/curses/PDCurses-3.4/pdcurses/inopts.c
new file mode 100644
index 0000000000..6d33fc2a38
--- /dev/null
+++ b/payloads/libpayload/curses/PDCurses-3.4/pdcurses/inopts.c
@@ -0,0 +1,321 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+RCSID("$Id: inopts.c,v 1.43 2008/07/13 16:08:18 wmcbrine Exp $")
+
+/*man-start**************************************************************
+
+  Name:                                                         inopts
+
+  Synopsis:
+        int cbreak(void);
+        int nocbreak(void);
+        int echo(void);
+        int noecho(void);
+        int halfdelay(int tenths);
+        int intrflush(WINDOW *win, bool bf);
+        int keypad(WINDOW *win, bool bf);
+        int meta(WINDOW *win, bool bf);
+        int nl(void);
+        int nonl(void);
+        int nodelay(WINDOW *win, bool bf);
+        int notimeout(WINDOW *win, bool bf);
+        int raw(void);
+        int noraw(void);
+        void noqiflush(void);
+        void qiflush(void);
+        void timeout(int delay);
+        void wtimeout(WINDOW *win, int delay);
+        int typeahead(int fildes);
+
+        int crmode(void);
+        int nocrmode(void);
+
+  Description:
+        cbreak() and nocbreak() toggle cbreak mode. In cbreak mode, 
+        characters typed by the user are made available immediately, and 
+        erase/kill character processing is not performed.  In nocbreak 
+        mode, typed characters are buffered until a newline or carriage 
+        return. Interrupt and flow control characters are unaffected by 
+        this mode. PDCurses always starts in cbreak mode.
+
+        echo() and noecho() control whether typed characters are echoed 
+        by the input routine.  Initially, input characters are echoed.  
+        Subsequent calls to echo() and noecho() do not flush type-ahead.
+
+        halfdelay() is similar to cbreak(), but allows for a time limit 
+        to be specified, in tenths of a second. This causes getch() to 
+        block for that period before returning ERR if no key has been 
+        received.  tenths must be between 1 and 255.
+
+        keypad() controls whether getch() returns function/special keys 
+        as single key codes (e.g., the left arrow key as KEY_LEFT). Per 
+        X/Open, the default for keypad mode is OFF. You'll probably want 
+        it on. With keypad mode off, if a special key is pressed, 
+        getch() does nothing or returns ERR.
+
+        nodelay() controls whether wgetch() is a non-blocking call. If 
+        the option is enabled, and no input is ready, wgetch() will 
+        return ERR. If disabled, wgetch() will hang until input is 
+        ready.
+
+        nl() enables the translation of a carriage return into a newline 
+        on input. nonl() disables this. Initially, the translation does 
+        occur.
+
+        raw() and noraw() toggle raw mode. Raw mode is similar to cbreak 
+        mode, in that characters typed are immediately passed through to 
+        the user program.  The difference is that in raw mode, the INTR, 
+        QUIT, SUSP, and STOP characters are passed through without being 
+        interpreted, and without generating a signal.
+
+        In PDCurses, the meta() function sets raw mode on or off.
+
+        timeout() and wtimeout() set blocking or non-blocking reads for 
+        the specified window. The delay is measured in milliseconds. If 
+        it's negative, a blocking read is used; if zero, then non- 
+        blocking reads are done -- if no input is waiting, ERR is 
+        returned immediately. If the delay is positive, the read blocks 
+        for the delay period; if the period expires, ERR is returned.
+
+        intrflush(), notimeout(), noqiflush(), qiflush() and typeahead()
+        do nothing in PDCurses, but are included for compatibility with 
+        other curses implementations.
+
+        crmode() and nocrmode() are archaic equivalents to cbreak() and 
+        nocbreak(), respectively.
+
+  Return Value:
+        All functions return OK on success and ERR on error.
+
+  Portability                                X/Open    BSD    SYS V
+        cbreak                                  Y       Y       Y
+        nocbreak                                Y       Y       Y
+        echo                                    Y       Y       Y
+        noecho                                  Y       Y       Y
+        halfdelay                               Y       -       Y
+        intrflush                               Y       -       Y
+        keypad                                  Y       -       Y
+        meta                                    Y       -       Y
+        nl                                      Y       Y       Y
+        nonl                                    Y       Y       Y
+        nodelay                                 Y       -       Y
+        notimeout                               Y       -       Y
+        raw                                     Y       Y       Y
+        noraw                                   Y       Y       Y
+        noqiflush                               Y       -       Y
+        qiflush                                 Y       -       Y
+        timeout                                 Y       -       Y
+        wtimeout                                Y       -       Y
+        typeahead                               Y       -       Y
+        crmode                                  -
+        nocrmode                                -
+
+**man-end****************************************************************/
+
+int cbreak(void)
+{
+    PDC_LOG(("cbreak() - called\n"));
+
+    SP->cbreak = TRUE;
+
+    return OK;
+}
+
+int nocbreak(void)
+{
+    PDC_LOG(("nocbreak() - called\n"));
+
+    SP->cbreak = FALSE;
+    SP->delaytenths = 0;
+
+    return OK;
+}
+
+int echo(void)
+{
+    PDC_LOG(("echo() - called\n"));
+
+    SP->echo = TRUE;
+
+    return OK;
+}
+
+int noecho(void)
+{
+    PDC_LOG(("noecho() - called\n"));
+
+    SP->echo = FALSE;
+
+    return OK;
+}
+
+int halfdelay(int tenths)
+{
+    PDC_LOG(("halfdelay() - called\n"));
+
+    if (tenths < 1 || tenths > 255)
+        return ERR;
+
+    SP->delaytenths = tenths;
+
+    return OK;
+}
+
+int intrflush(WINDOW *win, bool bf)
+{
+    PDC_LOG(("intrflush() - called\n"));
+
+    return OK;
+}
+
+int keypad(WINDOW *win, bool bf)
+{
+    PDC_LOG(("keypad() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_use_keypad = bf;
+
+    return OK;
+}
+
+int meta(WINDOW *win, bool bf)
+{
+    PDC_LOG(("meta() - called\n"));
+
+    SP->raw_inp = bf;
+
+    return OK;
+}
+
+int nl(void)
+{
+    PDC_LOG(("nl() - called\n"));
+
+    SP->autocr = TRUE;
+
+    return OK;
+}
+
+int nonl(void)
+{
+    PDC_LOG(("nonl() - called\n"));
+
+    SP->autocr = FALSE;
+
+    return OK;
+}
+
+int nodelay(WINDOW *win, bool flag)
+{
+    PDC_LOG(("nodelay() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_nodelay = flag;
+
+    return OK;
+}
+
+int notimeout(WINDOW *win, bool flag)
+{
+    PDC_LOG(("notimeout() - called\n"));
+
+    return OK;
+}
+
+int raw(void)
+{
+    PDC_LOG(("raw() - called\n"));
+
+    PDC_set_keyboard_binary(TRUE);
+    SP->raw_inp = TRUE;
+
+    return OK;
+}
+
+int noraw(void)
+{
+    PDC_LOG(("noraw() - called\n"));
+
+    PDC_set_keyboard_binary(FALSE);
+    SP->raw_inp = FALSE;
+
+    return OK;
+}
+
+void noqiflush(void)
+{
+    PDC_LOG(("noqiflush() - called\n"));
+}
+
+void qiflush(void)
+{
+    PDC_LOG(("qiflush() - called\n"));
+}
+
+int typeahead(int fildes)
+{
+    PDC_LOG(("typeahead() - called\n"));
+
+    return OK;
+}
+
+void wtimeout(WINDOW *win, int delay)
+{
+    PDC_LOG(("wtimeout() - called\n"));
+
+    if (!win)
+        return;
+
+    if (delay < 0)
+    {
+        /* This causes a blocking read on the window, so turn on delay 
+           mode */
+
+        win->_nodelay = FALSE;
+        win->_delayms = 0;
+    }
+    else if (!delay)
+    {
+        /* This causes a non-blocking read on the window, so turn off 
+           delay mode */
+
+        win->_nodelay = TRUE;
+        win->_delayms = 0;
+    }
+    else
+    {
+        /* This causes the read on the window to delay for the number of 
+           milliseconds. Also forces the window into non-blocking read 
+           mode */
+
+        /*win->_nodelay = TRUE;*/
+        win->_delayms = delay;
+    }
+}
+
+void timeout(int delay)
+{
+    PDC_LOG(("timeout() - called\n"));
+
+    wtimeout(stdscr, delay);
+}
+
+int crmode(void)
+{
+    PDC_LOG(("crmode() - called\n"));
+
+    return cbreak();
+}
+
+int nocrmode(void)
+{
+    PDC_LOG(("nocrmode() - called\n"));
+
+    return nocbreak();
+}